tsvesync 1.3.13 → 1.4.1

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

@@ -57,6 +57,14 @@ export declare class VeSyncAirBaseV2 extends VeSyncAirBypass {
      * Override setMode to send workMode payloads for bypassV2 purifiers.
      */
     setMode(mode: string): Promise<boolean>;
+    /**
+     * Convenience helper to enter turbo mode when supported.
+     */
+    turboMode(): Promise<boolean>;
+    /**
+     * Convenience helper to enter pet mode when supported.
+     */
+    petMode(): Promise<boolean>;
     /**
      * Override changeFanSpeed to use manualSpeedLevel for bypassV2 purifiers.
      */

package/dist/lib/fans/airBaseV2.js

@@ -13,11 +13,11 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
         this._lightDetection = false;
         this._lightDetectionState = false;
         this.setSpeedLevel = null;
-        this.autoPreferences = ['default', 'efficient', 'quiet'];
         this.enabled = false;
         this._mode = '';
         this._speed = 0;
         this._timer = null;
+        this.autoPreferences = [...this.getConfigAutoPreferences(['default', 'efficient', 'quiet'])];
         logger_1.logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
     }
     buildConfigDict(configDict) {
@@ -265,28 +265,63 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
      * Override setMode to send workMode payloads for bypassV2 purifiers.
      */
     async setMode(mode) {
-        if (!this.modes.includes(mode)) {
+        var _a, _b;
+        const targetMode = mode.toLowerCase();
+        const supportedModes = this.modes.map(m => m.toLowerCase());
+        if (!supportedModes.includes(targetMode)) {
             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);
         }
         // Special handling for Core200S stays the same for all models
-        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+        if (this.deviceType.includes('Core200S') && targetMode === 'auto') {
             logger_1.logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
             return this.setMode('manual');
         }
+        // Manual mode should leverage changeFanSpeed to mirror pyvesync behaviour
+        if (targetMode === 'manual') {
+            const defaultLevel = this.config.levels && this.config.levels.length > 0
+                ? this.config.levels[0]
+                : 1;
+            const desiredLevel = (_b = (_a = this.details.manualSpeedLevel) !== null && _a !== void 0 ? _a : this.speed) !== null && _b !== void 0 ? _b : defaultLevel;
+            const success = await this.changeFanSpeed(desiredLevel);
+            if (success) {
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+            }
+            return success;
+        }
         // BypassV2 purifiers need the workMode payload; other models use the base implementation
         if (this.requiresPowerSwitchPayload()) {
             logger_1.logger.debug(`Using bypassV2 mode payload for ${this.deviceName}`);
             const [head, body] = this.buildApiDict('setPurifierMode');
             body.payload.data = {
-                workMode: mode
+                workMode: targetMode
             };
             const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
             const success = this.checkV2Response(response, status, 'setMode');
             if (success) {
-                this.details.mode = mode;
-                this._mode = mode;
+                this.details.mode = targetMode;
+                this.mode = targetMode;
+                // Update cached speed snapshot for special modes
+                if (targetMode === 'sleep') {
+                    this.speed = 0;
+                    this.details.speed = 0;
+                }
+                else if (targetMode === 'turbo') {
+                    const maxSpeed = this.config.levels && this.config.levels.length > 0
+                        ? Math.max(...this.config.levels)
+                        : this.speed;
+                    if (typeof maxSpeed === 'number' && maxSpeed > 0) {
+                        this.speed = maxSpeed;
+                        this.details.speed = maxSpeed;
+                    }
+                }
+                else if (targetMode === 'auto') {
+                    this.speed = 0;
+                    this.details.speed = 0;
+                    this.details.isAutoSentinel = true;
+                }
                 // Force a details update to sync state
                 setTimeout(() => {
                     this.getDetails().catch(e => {
@@ -296,7 +331,7 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
                 return true;
             }
             else {
-                logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+                logger_1.logger.error(`Failed to set mode to ${targetMode} for device: ${this.deviceName}`);
                 return false;
             }
         }
@@ -305,6 +340,26 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             return super.setMode(mode);
         }
     }
+    /**
+     * Convenience helper to enter turbo mode when supported.
+     */
+    async turboMode() {
+        if (!this.modes.map(m => m.toLowerCase()).includes('turbo')) {
+            logger_1.logger.debug(`Turbo mode not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        return this.setMode('turbo');
+    }
+    /**
+     * Convenience helper to enter pet mode when supported.
+     */
+    async petMode() {
+        if (!this.modes.map(m => m.toLowerCase()).includes('pet')) {
+            logger_1.logger.debug(`Pet mode not supported for device: ${this.deviceName}`);
+            return false;
+        }
+        return this.setMode('pet');
+    }
     /**
      * Override changeFanSpeed to use manualSpeedLevel for bypassV2 purifiers.
      */
@@ -331,6 +386,10 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             if (success) {
                 this.speed = speed;
                 this.details.manualSpeedLevel = speed;
+                this.details.speed = speed;
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+                this.details.isAutoSentinel = false;
                 // Force a details update to sync state
                 setTimeout(() => {
                     this.getDetails().catch(e => {
@@ -357,6 +416,10 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             if (success) {
                 this.speed = speed;
                 this.details.manualSpeedLevel = speed;
+                this.details.speed = speed;
+                this.details.mode = 'manual';
+                this.mode = 'manual';
+                this.details.isAutoSentinel = false;
                 return true;
             }
             else {
@@ -370,7 +433,7 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
      */
     async setAutoPreference(preference = 'default', roomSize = 600) {
         if (!this.autoPreferences.includes(preference)) {
-            logger_1.logger.debug(`Invalid preference: ${preference} - valid preferences are default, efficient, quiet`);
+            logger_1.logger.debug(`Invalid preference: ${preference} - valid preferences are ${this.autoPreferences.join(', ')}`);
             return false;
         }
         const [head, body] = this.buildApiDict('setAutoPreference');

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

@@ -4,7 +4,7 @@ import { VeSync } from '../vesync';
  * VeSync Air Purifier with Bypass
  */
 export declare class VeSyncAirBypass extends VeSyncFan {
-    protected readonly modes: readonly ["auto", "manual", "sleep"];
+    protected get modes(): ReadonlyArray<string>;
     protected readonly displayModes: readonly ["on", "off"];
     protected readonly childLockModes: readonly ["on", "off"];
     constructor(details: Record<string, any>, manager: VeSync);

package/dist/lib/fans/airBypass.js

@@ -8,9 +8,11 @@ const logger_1 = require("../logger");
  * VeSync Air Purifier with Bypass
  */
 class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
+    get modes() {
+        return this.getConfigModes(['auto', 'manual', 'sleep']);
+    }
     constructor(details, manager) {
         super(details, manager);
-        this.modes = ['auto', 'manual', 'sleep'];
         this.displayModes = ['on', 'off'];
         this.childLockModes = ['on', 'off'];
         logger_1.logger.debug(`Initialized VeSyncAirBypass device: ${this.deviceName}`);
@@ -69,16 +71,30 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                         logger_1.logger.debug(`${this.deviceName}: API response structure:`, JSON.stringify(result, null, 2));
                     }
                 }
+                // Parse air quality with fallback support for multiple API response formats
+                // Some devices (like Core 400S) may use PascalCase (AQLevel, PM25)
+                // while others use snake_case (air_quality, air_quality_value)
+                const airQualityLevel = result.air_quality || result.AQLevel || 0;
+                const airQualityValue = result.air_quality_value || result.PM25 || 0;
+                // Debug logging to diagnose air quality field availability
+                logger_1.logger.debug(`${this.deviceName}: Air quality API response fields:`, {
+                    air_quality: result.air_quality,
+                    AQLevel: result.AQLevel,
+                    air_quality_value: result.air_quality_value,
+                    PM25: result.PM25,
+                    parsed_level: airQualityLevel,
+                    parsed_value: airQualityValue
+                });
                 this.details = {
                     mode: result.mode || '',
                     speed: result.level || 0,
                     filter_life: filterLife,
                     screen_status: result.display ? 'on' : 'off',
                     child_lock: result.child_lock || false,
-                    air_quality: result.air_quality || 0,
-                    air_quality_value: result.air_quality_value || 0
+                    air_quality: airQualityLevel,
+                    air_quality_value: airQualityValue
                 };
-                const normalizedAirQuality = helpers_1.Helpers.normalizeAirQuality(result.air_quality);
+                const normalizedAirQuality = helpers_1.Helpers.normalizeAirQuality(airQualityLevel);
                 if (normalizedAirQuality.level >= 1) {
                     this.details.air_quality_level = normalizedAirQuality.level;
                 }
@@ -90,6 +106,14 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                     this.details.pm10 = result.PM10;
                 if ('AQPercent' in result)
                     this.details.aq_percent = result.AQPercent;
+                // Debug log additional air quality fields for diagnostics
+                if (result.PM1 !== undefined || result.PM10 !== undefined || result.AQPercent !== undefined) {
+                    logger_1.logger.debug(`${this.deviceName}: Additional air quality data:`, {
+                        PM1: result.PM1,
+                        PM10: result.PM10,
+                        AQPercent: result.AQPercent
+                    });
+                }
                 // Don't overwrite config as it contains features array
                 if (result.configuration) {
                     this.details.configuration = result.configuration;
@@ -183,14 +207,17 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
      * Set device mode
      */
     async setMode(mode) {
-        if (!this.modes.includes(mode)) {
+        const requested = mode.toLowerCase();
+        const supported = this.modes.map(m => m.toLowerCase());
+        const allowsCore200AutoFallback = this.deviceType.includes('Core200S') && requested === 'auto';
+        if (!supported.includes(requested) && !allowsCore200AutoFallback) {
             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}`);
+        logger_1.logger.debug(`Setting mode to ${requested} for device: ${this.deviceName}`);
         // Special handling for Core200S auto mode
-        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+        if (allowsCore200AutoFallback) {
             // Core200S doesn't support auto mode, so we'll set it to manual mode
             logger_1.logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
             return this.setMode('manual');
@@ -202,7 +229,7 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
             configModule: this.configModule,
             payload: {
                 data: {
-                    mode
+                    mode: requested
                 },
                 method: 'setPurifierMode',
                 source: 'APP'
@@ -210,11 +237,11 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
         }, helpers_1.Helpers.reqHeaderBypass());
         const success = this.checkResponse([response, status], 'setMode');
         if (success) {
-            this.details.mode = mode;
+            this.details.mode = requested;
             return true;
         }
         else {
-            logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+            logger_1.logger.error(`Failed to set mode to ${requested} for device: ${this.deviceName}`);
             return false;
         }
     }

package/dist/lib/vesyncFan.d.ts

@@ -3,12 +3,15 @@
  */
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { VeSync } from './vesync';
+interface FanConfigEntry {
+    module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
+    features: string[];
+    levels?: number[];
+    modes?: ReadonlyArray<string>;
+    autoPreferences?: ReadonlyArray<string>;
+}
 interface FanConfig {
-    [key: string]: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
-        features: string[];
-        levels?: number[];
-    };
+    [key: string]: FanConfigEntry;
 }
 export declare const fanConfig: FanConfig;
 /**
@@ -42,16 +45,33 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
         duration: number;
         action: string;
     } | null;
-    protected config: {
-        module: 'VeSyncAirBypass' | 'VeSyncHumidifier' | 'VeSyncWarmHumidifier' | 'VeSyncTowerFan' | 'VeSyncAirBaseV2' | 'VeSyncSuperior6000S' | 'VeSyncHumid1000S' | 'VeSyncHumid200S' | 'VeSyncAir131';
-        features: string[];
-        levels?: number[];
-    };
+    protected config: FanConfigEntry;
     constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Find config entry by substring matching for variant device types
+     * Maps LAP variants to their base model configs (e.g., LAP-C401S-WUSR → Core400S)
+     */
+    private findConfigBySubstring;
     /**
      * Check if feature is supported
      */
     hasFeature(feature: string): boolean;
+    /**
+     * Get configured modes for the device, falling back to provided defaults.
+     */
+    protected getConfigModes(defaultModes?: ReadonlyArray<string>): ReadonlyArray<string>;
+    /**
+     * Get configured auto preferences for the device, falling back to provided defaults.
+     */
+    protected getConfigAutoPreferences(defaultPreferences?: ReadonlyArray<string>): ReadonlyArray<string>;
+    /**
+     * Public accessor for supported modes for consumers that need to inspect capability metadata.
+     */
+    getSupportedModes(defaultModes?: ReadonlyArray<string>): ReadonlyArray<string>;
+    /**
+     * Public accessor for supported auto preference profiles.
+     */
+    getSupportedAutoPreferences(defaultPreferences?: ReadonlyArray<string>): ReadonlyArray<string>;
     /**
      * Check if feature is supported in current mode
      */