meross-iot 0.1.0

package/lib/model/states/timer-state.js

@@ -0,0 +1,192 @@
+'use strict';
+
+/**
+ * Represents the state of a timer configuration.
+ *
+ * Encapsulates state information for device timer configurations. Timers can be used
+ * to schedule device actions at specific times or intervals. State instances are
+ * managed by device controllers and updated automatically when device responses or
+ * push notifications are received.
+ *
+ * @class
+ * @example
+ * const timerState = device.getCachedTimerState(timerId);
+ * if (timerState) {
+ *     console.log('Timer enabled:', timerState.enable);
+ *     console.log('Timer type:', timerState.type);
+ *     console.log('Scheduled time:', timerState.time);
+ * }
+ */
+class TimerState {
+    /**
+     * Creates a new TimerState instance.
+     *
+     * @param {Object} [state=null] - Initial state object
+     * @param {string|number} [state.id] - Timer identifier
+     * @param {number} [state.channel] - Channel number
+     * @param {number} [state.week] - Weekday mask (bitmask for days of week)
+     * @param {number} [state.time] - Time value (minutes since midnight or timestamp)
+     * @param {number} [state.enable] - Enabled state (0=disabled, 1=enabled)
+     * @param {string} [state.alias] - Timer alias/name
+     * @param {number} [state.type] - Timer type (from TimerType enum)
+     * @param {number} [state.duration] - Duration value (for countdown timers)
+     * @param {number} [state.sunOffset] - Sunrise/sunset offset (for sun-based timers)
+     * @param {number} [state.createTime] - Creation timestamp
+     * @param {Object} [state.extend] - Extended configuration data
+     */
+    constructor(state = null) {
+        this._state = state || {};
+    }
+
+    /**
+     * Updates the state with new data.
+     *
+     * Merges new state data into the existing state using Object.assign to preserve
+     * properties not included in the update. Called automatically by device controllers
+     * when state updates are received from device responses or push notifications.
+     *
+     * @param {Object} state - New state data to merge
+     */
+    update(state) {
+        if (state) {
+            Object.assign(this._state, state);
+        }
+    }
+
+    /**
+     * Gets the timer identifier.
+     *
+     * @returns {string|number|undefined} Timer ID or undefined if not available
+     */
+    get id() {
+        return this._state.id;
+    }
+
+    /**
+     * Gets the channel number.
+     *
+     * @returns {number|undefined} Channel number or undefined if not available
+     */
+    get channel() {
+        const { channel } = this._state;
+        if (channel === undefined || channel === null) {return undefined;}
+        return channel;
+    }
+
+    /**
+     * Gets the weekday mask.
+     *
+     * Bitmask representing which days of the week the timer is active. Use bitwise
+     * operations to check for specific days.
+     *
+     * @returns {number|undefined} Weekday mask or undefined if not available
+     */
+    get week() {
+        const { week } = this._state;
+        if (week === undefined || week === null) {return undefined;}
+        return week;
+    }
+
+    /**
+     * Gets the time value.
+     *
+     * Interpretation depends on timer type: for daily timers it's minutes since
+     * midnight, for other types it may be a Unix timestamp.
+     *
+     * @returns {number|undefined} Time value (minutes since midnight or timestamp) or undefined if not available
+     */
+    get time() {
+        const { time } = this._state;
+        if (time === undefined || time === null) {return undefined;}
+        return time;
+    }
+
+    /**
+     * Gets whether the timer is enabled.
+     *
+     * Converts the device's numeric enabled state (0 or 1) to a boolean for easier
+     * conditional logic in application code.
+     *
+     * @returns {boolean|undefined} True if enabled, false if disabled, undefined if state not available
+     */
+    get enable() {
+        const { enable } = this._state;
+        if (enable === undefined || enable === null) {return undefined;}
+        return enable === 1;
+    }
+
+    /**
+     * Gets the timer alias/name.
+     *
+     * @returns {string|undefined} Timer alias or undefined if not available
+     */
+    get alias() {
+        return this._state.alias;
+    }
+
+    /**
+     * Gets the timer type.
+     *
+     * @returns {number|undefined} Timer type value or undefined if not available
+     * @see {@link module:lib/enums.TimerType} for type constants
+     */
+    get type() {
+        const { type } = this._state;
+        if (type === undefined || type === null) {return undefined;}
+        return type;
+    }
+
+    /**
+     * Gets the duration value.
+     *
+     * Specifies how long a countdown timer should run. Only relevant for countdown
+     * timer types.
+     *
+     * @returns {number|undefined} Duration value or undefined if not available
+     */
+    get duration() {
+        const { duration } = this._state;
+        if (duration === undefined || duration === null) {return undefined;}
+        return duration;
+    }
+
+    /**
+     * Gets the sunrise/sunset offset.
+     *
+     * Specifies the offset in minutes from sunrise or sunset for sun-based timers.
+     * Only relevant for timer types that use solar calculations.
+     *
+     * @returns {number|undefined} Sun offset value in minutes or undefined if not available
+     */
+    get sunOffset() {
+        const { sunOffset } = this._state;
+        if (sunOffset === undefined || sunOffset === null) {return undefined;}
+        return sunOffset;
+    }
+
+    /**
+     * Gets the creation timestamp.
+     *
+     * @returns {number|undefined} Creation timestamp or undefined if not available
+     */
+    get createTime() {
+        const { createTime } = this._state;
+        if (createTime === undefined || createTime === null) {return undefined;}
+        return createTime;
+    }
+
+    /**
+     * Gets the extended configuration data.
+     *
+     * Returns additional timer configuration that may not be covered by standard
+     * properties. Structure varies by device and timer type.
+     *
+     * @returns {Object|undefined} Extended configuration object or undefined if not available
+     */
+    get extend() {
+        return this._state.extend;
+    }
+}
+
+module.exports = TimerState;
+

package/lib/model/states/toggle-state.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * Represents the toggle (on/off) state of a device channel.
+ *
+ * Encapsulates state information for toggle devices (smart plugs, switches, etc.).
+ * State instances are managed by device controllers and updated automatically when
+ * device responses or push notifications are received.
+ *
+ * @class
+ * @example
+ * const toggleState = device.getCachedToggleState(0);
+ * if (toggleState && toggleState.isOn) {
+ *     console.log('Device is on');
+ * }
+ */
+class ToggleState {
+    /**
+     * Creates a new ToggleState instance.
+     *
+     * @param {Object} [state=null] - Initial state object
+     * @param {number} [state.onoff] - On/off state (0=off, 1=on)
+     * @param {number} [state.channel] - Channel number
+     * @param {number} [state.lmTime] - Last modified timestamp
+     * @param {number} [state.entity] - Entity identifier
+     */
+    constructor(state = null) {
+        this._state = state || {};
+    }
+
+    /**
+     * Updates the state with new data
+     *
+     * Merges new state data into the existing state. Called automatically by the device
+     * when state updates are received.
+     *
+     * @param {Object} state - New state data to merge
+     */
+    update(state) {
+        if (state) {
+            Object.assign(this._state, state);
+        }
+    }
+
+    /**
+     * Gets whether the device is on (as boolean)
+     *
+     * @returns {boolean|undefined} True if on, false if off, undefined if state not available
+     */
+    get isOn() {
+        const { onoff } = this._state;
+        if (onoff === undefined || onoff === null) {return undefined;}
+        return onoff === 1;
+    }
+
+    /**
+     * Gets the raw on/off state value.
+     *
+     * Returns the numeric on/off state as stored by the device. Use this when you
+     * need the exact format used in device communication protocols.
+     *
+     * @returns {number|undefined} 0 if off, 1 if on, undefined if not available
+     */
+    get onoff() {
+        const { onoff } = this._state;
+        if (onoff === undefined || onoff === null) {return undefined;}
+        return onoff;
+    }
+
+    /**
+     * Gets the channel number.
+     *
+     * @returns {number|undefined} Channel number or undefined if not available
+     */
+    get channel() {
+        const { channel } = this._state;
+        if (channel === undefined || channel === null) {return undefined;}
+        return channel;
+    }
+
+    /**
+     * Gets the last modified timestamp.
+     *
+     * @returns {number|undefined} Timestamp or undefined if not available
+     */
+    get lmTime() {
+        const { lmTime } = this._state;
+        if (lmTime === undefined || lmTime === null) {return undefined;}
+        return lmTime;
+    }
+
+    /**
+     * Gets the entity identifier.
+     *
+     * @returns {number|undefined} Entity ID or undefined if not available
+     */
+    get entity() {
+        const { entity } = this._state;
+        if (entity === undefined || entity === null) {return undefined;}
+        return entity;
+    }
+}
+
+module.exports = ToggleState;
+

package/lib/model/states/trigger-state.js

@@ -0,0 +1,155 @@
+'use strict';
+
+/**
+ * Represents the state of a trigger configuration.
+ *
+ * Encapsulates state information for device trigger configurations. Triggers can be
+ * used to create automation rules that respond to device events. State instances are
+ * managed by device controllers and updated automatically when device responses or
+ * push notifications are received.
+ *
+ * @class
+ * @example
+ * const triggerState = device.getCachedTriggerState(triggerId);
+ * if (triggerState) {
+ *     console.log('Trigger enabled:', triggerState.enable);
+ *     console.log('Trigger type:', triggerState.type);
+ *     console.log('Rule duration:', triggerState.ruleDuration);
+ * }
+ */
+class TriggerState {
+    /**
+     * Creates a new TriggerState instance.
+     *
+     * @param {Object} [state=null] - Initial state object
+     * @param {string|number} [state.id] - Trigger identifier
+     * @param {number} [state.channel] - Channel number
+     * @param {string} [state.alias] - Trigger alias/name
+     * @param {number} [state.enable] - Enabled state (0=disabled, 1=enabled)
+     * @param {number} [state.type] - Trigger type (from TriggerType enum)
+     * @param {number} [state.createTime] - Creation timestamp
+     * @param {Object} [state.rule] - Rule configuration object
+     * @param {number} [state.rule.duration] - Rule duration value
+     * @param {number} [state.rule.week] - Rule weekday mask
+     */
+    constructor(state = null) {
+        this._state = state || {};
+    }
+
+    /**
+     * Updates the state with new data
+     *
+     * Merges new state data into the existing state. Called automatically by the device
+     * when state updates are received.
+     *
+     * @param {Object} state - New state data to merge
+     */
+    update(state) {
+        if (state) {
+            Object.assign(this._state, state);
+        }
+    }
+
+    /**
+     * Gets the trigger identifier.
+     *
+     * @returns {string|number|undefined} Trigger ID or undefined if not available
+     */
+    get id() {
+        return this._state.id;
+    }
+
+    /**
+     * Gets the channel number.
+     *
+     * @returns {number|undefined} Channel number or undefined if not available
+     */
+    get channel() {
+        const { channel } = this._state;
+        if (channel === undefined || channel === null) {return undefined;}
+        return channel;
+    }
+
+    /**
+     * Gets the trigger alias/name.
+     *
+     * @returns {string|undefined} Trigger alias or undefined if not available
+     */
+    get alias() {
+        return this._state.alias;
+    }
+
+    /**
+     * Gets whether the trigger is enabled.
+     *
+     * Converts the device's numeric enabled state (0 or 1) to a boolean for easier
+     * conditional logic in application code.
+     *
+     * @returns {boolean|undefined} True if enabled, false if disabled, undefined if state not available
+     */
+    get enable() {
+        const { enable } = this._state;
+        if (enable === undefined || enable === null) {return undefined;}
+        return enable === 1;
+    }
+
+    /**
+     * Gets the trigger type.
+     *
+     * @returns {number|undefined} Trigger type value or undefined if not available
+     * @see {@link module:lib/enums.TriggerType} for type constants
+     */
+    get type() {
+        const { type } = this._state;
+        if (type === undefined || type === null) {return undefined;}
+        return type;
+    }
+
+    /**
+     * Gets the creation timestamp.
+     *
+     * @returns {number|undefined} Creation timestamp or undefined if not available
+     */
+    get createTime() {
+        const { createTime } = this._state;
+        if (createTime === undefined || createTime === null) {return undefined;}
+        return createTime;
+    }
+
+    /**
+     * Gets the rule configuration object
+     *
+     * @returns {Object|undefined} Rule configuration object or undefined if not available
+     */
+    get rule() {
+        return this._state.rule;
+    }
+
+    /**
+     * Gets the rule duration value.
+     *
+     * @returns {number|undefined} Rule duration or undefined if not available
+     */
+    get ruleDuration() {
+        const { rule } = this._state;
+        if (!rule) {return undefined;}
+        return rule.duration;
+    }
+
+    /**
+     * Gets the rule weekday mask.
+     *
+     * Bitmask representing which days of the week the trigger rule is active. Use
+     * bitwise operations to check for specific days.
+     *
+     * @returns {number|undefined} Weekday mask or undefined if not available
+     */
+    get ruleWeek() {
+        const { rule } = this._state;
+        if (!rule) {return undefined;}
+        return rule.week;
+    }
+}
+
+module.exports = TriggerState;
+