tsvesync 1.0.64 → 1.0.66

package/dist/lib/fans/towerFan.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncTowerFan = void 0;
+const airBaseV2_1 = require("./airBaseV2");
+const logger_1 = require("../logger");
+/**
+ * VeSync Tower Fan Implementation
+ */
+class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
+    constructor(details, manager) {
+        super(details, manager);
+        this.towerModes = ['normal', 'advancedSleep', 'off'];
+        logger_1.logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getTowerFanStatus');
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        if (!this.checkResponse([response, status], 'getDetails') || !(response === null || response === void 0 ? void 0 : response.result)) {
+            logger_1.logger.debug('Error getting tower fan details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const innerResponse = response.result;
+        if (innerResponse.code !== 0 || !innerResponse.result) {
+            logger_1.logger.debug('Error in inner response from tower fan');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const deviceData = innerResponse.result;
+        this.deviceStatus = deviceData.powerSwitch === 1 ? 'on' : 'off';
+        this.details = {
+            powerSwitch: deviceData.powerSwitch,
+            workMode: deviceData.workMode,
+            manualSpeedLevel: deviceData.manualSpeedLevel,
+            fanSpeedLevel: deviceData.fanSpeedLevel,
+            screenState: deviceData.screenState,
+            screenSwitch: deviceData.screenSwitch,
+            oscillationState: deviceData.oscillationState,
+            oscillationSwitch: deviceData.oscillationSwitch,
+            timerRemain: deviceData.timerRemain,
+            temperature: deviceData.temperature || 0,
+            humidity: deviceData.humidity || 0,
+            thermalComfort: deviceData.thermalComfort,
+            sleepPreference: deviceData.sleepPreference || {},
+            scheduleCount: deviceData.scheduleCount,
+            displayingType: deviceData.displayingType,
+            errorCode: deviceData.errorCode
+        };
+        logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        return true;
+    }
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle) {
+        if (typeof toggle !== 'boolean') {
+            logger_1.logger.debug('Invalid toggle value for tower fan switch');
+            return false;
+        }
+        const [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            powerSwitch: toggle ? 1 : 0,
+            switchIdx: 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = toggle ? 'on' : 'off';
+        }
+        else {
+            logger_1.logger.debug('Error toggling tower fan power');
+        }
+        return success;
+    }
+    /**
+     * Turn device on
+     */
+    async turnOn() {
+        logger_1.logger.debug(`Turning on device: ${this.deviceName}`);
+        return this.toggleSwitch(true);
+    }
+    /**
+     * Turn device off
+     */
+    async turnOff() {
+        logger_1.logger.debug(`Turning off device: ${this.deviceName}`);
+        return this.toggleSwitch(false);
+    }
+    /**
+     * Set tower fan mode
+     */
+    async mode_toggle(mode) {
+        if (!this.towerModes.includes(mode)) {
+            logger_1.logger.debug(`Invalid mode: ${mode}. Must be one of: ${this.towerModes.join(', ')}`);
+            return false;
+        }
+        if (mode === 'off') {
+            return this.turnOff();
+        }
+        const [head, body] = this.buildApiDict('setTowerFanMode');
+        body.deviceId = this.cid;
+        body.payload.data = {
+            workMode: mode
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'mode_toggle');
+        if (success) {
+            this.details.workMode = mode;
+        }
+        else {
+            logger_1.logger.error(`Failed to set ${mode} mode for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Change fan speed
+     */
+    async changeFanSpeed(speed) {
+        // const speeds = this.config.levels ?? [];
+        // if (!speeds.includes(speed)) {
+        //     logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
+        //     return false;
+        // }
+        const [head, body] = this.buildApiDict('setLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            levelType: 'wind',
+            manualSpeedLevel: speed
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'changeFanSpeed');
+        if (success) {
+            this.details.manualSpeedLevel = speed;
+        }
+        else {
+            logger_1.logger.debug('Error setting fan speed');
+        }
+        return success;
+    }
+    /**
+     * Set normal mode
+     */
+    async normal_mode() {
+        logger_1.logger.debug(`Setting normal mode for device: ${this.deviceName}`);
+        return this.mode_toggle('normal');
+    }
+    /**
+     * Set manual mode - adapter to set mode to normal
+     */
+    async manual_mode() {
+        logger_1.logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        return this.normal_mode();
+    }
+    /**
+     * Set advanced sleep mode
+     */
+    async advanced_sleep_mode() {
+        logger_1.logger.debug(`Setting advanced sleep mode for device: ${this.deviceName}`);
+        return this.mode_toggle('advancedSleep');
+    }
+    /**
+     * Set sleep mode - adapter for advanced sleep mode
+     */
+    async sleep_mode() {
+        logger_1.logger.debug(`Setting sleep mode for device: ${this.deviceName}`);
+        return this.advanced_sleep_mode();
+    }
+    /**
+     * Override setMode to handle tower fan specific modes
+     */
+    async setMode(mode) {
+        return this.mode_toggle(mode);
+    }
+    /**
+     * Get current speed
+     */
+    get speed() {
+        return this.details.manualSpeedLevel || 0;
+    }
+    /**
+     * Get display status
+     */
+    get displayState() {
+        return Boolean(this.details.screenState);
+    }
+    /**
+     * Get oscillation status
+     */
+    get oscillationState() {
+        return Boolean(this.details.oscillationState);
+    }
+    /**
+     * Get mute status
+     */
+    get muteState() {
+        return Boolean(this.details.muteState);
+    }
+    /**
+     * Get temperature (in tenths of a degree)
+     */
+    get temperature() {
+        return this.details.temperature || 0;
+    }
+    /**
+     * Get humidity percentage
+     */
+    get humidity() {
+        return this.details.humidity || 0;
+    }
+    /**
+     * Get thermal comfort level
+     */
+    get thermalComfort() {
+        return this.details.thermalComfort || 0;
+    }
+    /**
+     * Get sleep preferences
+     */
+    get sleepPreference() {
+        return this.details.sleepPreference || {};
+    }
+    /**
+     * Get schedule count
+     */
+    get scheduleCount() {
+        return this.details.scheduleCount || 0;
+    }
+    /**
+     * Get error code
+     */
+    get errorCode() {
+        return this.details.errorCode || 0;
+    }
+    /**
+     * Turn oscillation on
+     */
+    async setOscillationOn() {
+        return this.setOscillation(true);
+    }
+    /**
+     * Turn oscillation off
+     */
+    async setOscillationOff() {
+        return this.setOscillation(false);
+    }
+    /**
+     * Display device info
+     */
+    display() {
+        super.display();
+        const info = [
+            ['Mode: ', this.details.workMode || ''],
+            ['Speed: ', this.speed],
+            ['Fan Speed Level: ', this.details.fanSpeedLevel || 0],
+            ['Display: ', this.displayState],
+            ['Display Switch: ', this.details.screenSwitch],
+            ['Oscillation: ', this.oscillationState],
+            ['Oscillation Switch: ', this.details.oscillationSwitch],
+            ['Mute: ', this.muteState],
+            ['Mute Switch: ', this.details.muteSwitch],
+            ['Timer: ', this.timer],
+            ['Temperature: ', this.temperature / 10, '°C'],
+            ['Humidity: ', this.humidity, '%'],
+            ['Thermal Comfort: ', this.thermalComfort],
+            ['Sleep Preference: ', JSON.stringify(this.sleepPreference)],
+            ['Schedule Count: ', this.scheduleCount],
+            ['Displaying Type: ', this.details.displayingType],
+            ['Error Code: ', this.errorCode]
+        ];
+        for (const [key, value, unit = ''] of info) {
+            logger_1.logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
+        }
+    }
+}
+exports.VeSyncTowerFan = VeSyncTowerFan;

package/dist/lib/fans/warmHumidifier.d.ts

@@ -0,0 +1,49 @@
+import { VeSyncHumidifier } from './humidifier';
+import { VeSync } from '../vesync';
+/**
+ * VeSync Warm Humidifier Class
+ */
+export declare class VeSyncWarmHumidifier extends VeSyncHumidifier {
+    protected readonly warmLevels: number[];
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Get device details
+     */
+    getDetails(): Promise<Boolean>;
+    /**
+     * Change fan speed - Implemented to satisfy interface but redirects to setMistLevel
+     */
+    changeFanSpeed(speed: number): Promise<boolean>;
+    /**
+     * Set device mode
+     */
+    setMode(mode: string): Promise<boolean>;
+    /**
+     * Set warm mist level
+     */
+    setWarmLevel(level: number): Promise<boolean>;
+    /**
+     * Set drying mode enabled
+     */
+    setDryingModeEnabled(enabled: boolean): Promise<boolean>;
+    /**
+     * Get warm mist enabled status
+     */
+    get warmMistEnabled(): boolean;
+    /**
+     * Get drying mode enabled status
+     */
+    get dryingModeEnabled(): boolean;
+    /**
+     * Get drying mode state
+     */
+    get dryingModeState(): string;
+    /**
+     * Get drying mode level
+     */
+    get dryingModeLevel(): number;
+    /**
+     * Get drying mode seconds remaining
+     */
+    get dryingModeSecondsRemaining(): number;
+}

package/dist/lib/fans/warmHumidifier.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncWarmHumidifier = void 0;
+const humidifier_1 = require("./humidifier");
+const helpers_1 = require("../helpers");
+const logger_1 = require("../logger");
+/**
+ * VeSync Warm Humidifier Class
+ */
+class VeSyncWarmHumidifier extends humidifier_1.VeSyncHumidifier {
+    constructor(details, manager) {
+        super(details, manager);
+        this.warmLevels = [1, 2, 3];
+        logger_1.logger.debug(`Initialized VeSyncWarmHumidifier device: ${this.deviceName}`);
+    }
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        const success = await super.getDetails();
+        if (success && this.details) {
+            // Add warm humidifier specific fields
+            this.details = {
+                ...this.details,
+                warm_enabled: Boolean(this.details.warm_level && this.details.warm_level > 0),
+                drying_mode_enabled: this.details.autoDryingSwitch === 1,
+                drying_mode_state: this.details.dryingMode || '',
+                drying_mode_level: this.details.dryingLevel || 0,
+                drying_mode_seconds_remaining: this.details.dryingRemainTime || 0
+            };
+        }
+        return success;
+    }
+    /**
+     * Change fan speed - Implemented to satisfy interface but redirects to setMistLevel
+     */
+    async changeFanSpeed(speed) {
+        logger_1.logger.debug(`Redirecting fan speed change to mist level for device: ${this.deviceName}`);
+        return this.setMistLevel(speed);
+    }
+    /**
+     * Set device mode
+     */
+    async setMode(mode) {
+        if (!this.modes.includes(mode)) {
+            const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting mode to ${mode} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    mode
+                },
+                method: 'setHumidityMode',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setMode');
+        if (success) {
+            this.details.mode = mode;
+        }
+        else {
+            logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set warm mist level
+     */
+    async setWarmLevel(level) {
+        if (!this.hasFeature('warm')) {
+            const error = 'Warm mist control not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        if (!this.warmLevels.includes(level)) {
+            const error = `Invalid warm level: ${level}. Must be one of: ${this.warmLevels.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting warm level to ${level} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    id: 0,
+                    level: level,
+                    type: 'warm'
+                },
+                method: 'setLevel',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setWarmLevel');
+        if (success) {
+            this.details.warm_level = level;
+            this.details.warm_enabled = level > 0;
+        }
+        else {
+            logger_1.logger.error(`Failed to set warm level to ${level} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Set drying mode enabled
+     */
+    async setDryingModeEnabled(enabled) {
+        if (!this.hasFeature('drying')) {
+            const error = 'Drying mode not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        logger_1.logger.debug(`Setting drying mode to ${enabled} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    autoDryingSwitch: enabled ? 1 : 0
+                },
+                method: 'setDryingMode',
+                source: 'APP'
+            }
+        }, helpers_1.Helpers.reqHeaderBypass());
+        const success = this.checkResponse([response, status], 'setDryingModeEnabled');
+        if (success) {
+            this.details.drying_mode_enabled = enabled;
+            this.details.autoDryingSwitch = enabled ? 1 : 0;
+        }
+        else {
+            logger_1.logger.error(`Failed to set drying mode to ${enabled} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+    /**
+     * Get warm mist enabled status
+     */
+    get warmMistEnabled() {
+        return this.details.warm_enabled || false;
+    }
+    /**
+     * Get drying mode enabled status
+     */
+    get dryingModeEnabled() {
+        return this.details.drying_mode_enabled || false;
+    }
+    /**
+     * Get drying mode state
+     */
+    get dryingModeState() {
+        return this.details.drying_mode_state || '';
+    }
+    /**
+     * Get drying mode level
+     */
+    get dryingModeLevel() {
+        return this.details.drying_mode_level || 0;
+    }
+    /**
+     * Get drying mode seconds remaining
+     */
+    get dryingModeSecondsRemaining() {
+        return this.details.drying_mode_seconds_remaining || 0;
+    }
+}
+exports.VeSyncWarmHumidifier = VeSyncWarmHumidifier;

package/dist/lib/vesyncFan.d.ts

@@ -19,7 +19,7 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
         mode?: string;
         speed?: number;
         filter_life?: number;
-        screen_status?: string;
+        screen_status?: 'on' | 'off';
         child_lock?: boolean;
         air_quality?: string;
         humidity?: number;
@@ -59,7 +59,7 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
     /**
      * Get screen status
      */
-    get screenStatus(): string;
+    get screenStatus(): 'on' | 'off';
     /**
      * Get child lock status
      */

package/dist/lib/vesyncFan.js

@@ -11,7 +11,7 @@ exports.fanConfig = {
     // Core Series
     'Core200S': {
         module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer'],
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode'],
         levels: [1, 2, 3]
     },
     'Core300S': {
@@ -343,7 +343,7 @@ class VeSyncFan extends vesyncBaseDevice_1.VeSyncBaseDevice {
      */
     get screenStatus() {
         var _a;
-        return (_a = this.details.screen_status) !== null && _a !== void 0 ? _a : '';
+        return (_a = this.details.screen_status) !== null && _a !== void 0 ? _a : 'off';
     }
     /**
      * Get child lock status