tsvesync 1.0.90 → 1.0.92

package/dist/__tests__/fans/vesyncAirBypass.test.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * Unit tests for VeSyncAirBypass air quality data parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const airBypass_1 = require("../../lib/fans/airBypass");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+describe('VeSyncAirBypass Air Quality Features', () => {
+    let device;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'Core300S Test',
+            deviceType: 'Core300S',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'on',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAirBypass',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        device = new airBypass_1.VeSyncAirBypass(deviceDetails, mockManager);
+    });
+    describe('Air Quality Data Parsing', () => {
+        it('should parse air quality data from device response', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 3,
+                        speed: 3,
+                        display: 'on',
+                        child_lock: false,
+                        night_light: 'dim',
+                        air_quality: 2,
+                        air_quality_value: 15,
+                        filter_life: 85,
+                        timer_remain: 0
+                    }
+                }
+            };
+            // Simulate API response parsing
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(15);
+            expect(device.filterLife).toBe(85);
+        });
+        it('should handle missing air quality data gracefully', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 3,
+                        speed: 3,
+                        display: 'on',
+                        child_lock: false,
+                        filter_life: 85
+                        // air_quality and air_quality_value missing
+                    }
+                }
+            };
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(85);
+        });
+        it('should handle various air quality value ranges', () => {
+            const testCases = [
+                { value: 0, level: 1, expected: 'Excellent' },
+                { value: 12, level: 1, expected: 'Good' },
+                { value: 25, level: 2, expected: 'Fair' },
+                { value: 55, level: 3, expected: 'Inferior' },
+                { value: 150, level: 4, expected: 'Poor' },
+                { value: 500, level: 5, expected: 'Poor' }
+            ];
+            testCases.forEach(testCase => {
+                device.details = {
+                    air_quality: testCase.level,
+                    air_quality_value: testCase.value,
+                    filter_life: 50
+                };
+                expect(device.airQualityValue).toBe(testCase.value);
+                expect(device.airQualityLevel).toBe(testCase.level);
+            });
+        });
+        it('should handle extended air quality data with PM1 and PM10', () => {
+            device.details = {
+                air_quality: 2,
+                air_quality_value: 20,
+                pm1: 15,
+                pm10: 35,
+                aq_percent: 75,
+                filter_life: 60
+            };
+            expect(device.airQualityValue).toBe(20);
+            expect(device.pm1).toBe(15);
+            expect(device.pm10).toBe(35);
+            expect(device.aqPercent).toBe(75);
+        });
+        it('should handle zero PM values correctly', () => {
+            device.details = {
+                air_quality: 1,
+                air_quality_value: 0,
+                pm1: 0,
+                pm10: 0,
+                aq_percent: 100,
+                filter_life: 100
+            };
+            expect(device.airQualityValue).toBe(0);
+            expect(device.pm1).toBe(0);
+            expect(device.pm10).toBe(0);
+            expect(device.aqPercent).toBe(100);
+        });
+    });
+    describe('Filter Life Parsing', () => {
+        it('should parse filter life as number', () => {
+            device.details = { filter_life: 75 };
+            expect(device.filterLife).toBe(75);
+        });
+        it('should handle zero filter life', () => {
+            device.details = { filter_life: 0 };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle 100% filter life', () => {
+            device.details = { filter_life: 100 };
+            expect(device.filterLife).toBe(100);
+        });
+        it('should handle missing filter life data', () => {
+            device.details = { mode: 'auto', speed: 3 };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle invalid filter life data types', () => {
+            device.details = { filter_life: 'invalid' };
+            expect(device.filterLife).toBe(0);
+        });
+    });
+    describe('Feature Support', () => {
+        it('should support air quality features for Core300S', () => {
+            expect(device.hasFeature('air_quality')).toBe(true);
+            expect(device.hasFeature('auto_mode')).toBe(true);
+            expect(device.hasFeature('display')).toBe(true);
+            expect(device.hasFeature('child_lock')).toBe(true);
+            expect(device.hasFeature('night_light')).toBe(true);
+        });
+        it('should not support air quality for Core200S', () => {
+            const core200s = new airBypass_1.VeSyncAirBypass({
+                deviceName: 'Core200S Test',
+                deviceType: 'Core200S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(core200s.hasFeature('air_quality')).toBe(false);
+            expect(core200s.hasFeature('auto_mode')).toBe(false);
+        });
+        it('should return correct max speed for different models', () => {
+            expect(device.getMaxFanSpeed()).toBe(4); // Core300S has 4 speeds
+            const core200s = new airBypass_1.VeSyncAirBypass({
+                deviceName: 'Core200S Test',
+                deviceType: 'Core200S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(core200s.getMaxFanSpeed()).toBe(3); // Core200S has 3 speeds
+        });
+    });
+    describe('Device State Management', () => {
+        it('should track device state correctly', () => {
+            device.details = {
+                enabled: true,
+                mode: 'auto',
+                level: 3,
+                speed: 3,
+                display: 'on',
+                child_lock: false,
+                air_quality: 2,
+                air_quality_value: 25,
+                filter_life: 65
+            };
+            expect(device.deviceStatus).toBe('on');
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(3);
+            expect(device.screenStatus).toBe('on');
+            expect(device.childLock).toBe(false);
+        });
+        it('should handle device off state', () => {
+            device.deviceStatus = 'off';
+            device.details = {
+                enabled: false,
+                mode: 'manual',
+                level: 0,
+                speed: 0,
+                air_quality_value: 0
+            };
+            expect(device.deviceStatus).toBe('off');
+            expect(device.speed).toBe(0);
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle malformed API responses', () => {
+            device.details = null;
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+            expect(device.mode).toBe('');
+            expect(device.speed).toBe(0);
+        });
+        it('should handle partial API responses', () => {
+            device.details = {
+                mode: 'auto'
+                // Other fields missing
+            };
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(0);
+        });
+        it('should handle negative values gracefully', () => {
+            device.details = {
+                air_quality_value: -10,
+                pm1: -5,
+                pm10: -15,
+                filter_life: -20
+            };
+            expect(device.airQualityValue).toBe(-10); // Allow negative for error detection
+            expect(device.pm1).toBe(-5);
+            expect(device.pm10).toBe(-15);
+            expect(device.filterLife).toBe(-20);
+        });
+        it('should handle extremely high values', () => {
+            device.details = {
+                air_quality_value: 9999,
+                pm1: 5000,
+                pm10: 8000,
+                filter_life: 200,
+                aq_percent: 150
+            };
+            expect(device.airQualityValue).toBe(9999);
+            expect(device.pm1).toBe(5000);
+            expect(device.pm10).toBe(8000);
+            expect(device.filterLife).toBe(200);
+            expect(device.aqPercent).toBe(150);
+        });
+    });
+});

package/dist/__tests__/vesyncFan.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncFan base class and air quality features
+ */
+export {};

package/dist/__tests__/vesyncFan.test.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * Unit tests for VeSyncFan base class and air quality features
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vesyncFan_1 = require("../lib/vesyncFan");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+// Test implementation of abstract VeSyncFan class
+class TestVeSyncFan extends vesyncFan_1.VeSyncFan {
+    async getDetails() {
+        return true;
+    }
+    async turnOn() {
+        this.deviceStatus = 'on';
+        return true;
+    }
+    async turnOff() {
+        this.deviceStatus = 'off';
+        return true;
+    }
+    async changeFanSpeed(level) {
+        this.details.speed = level;
+        return true;
+    }
+    async changeMode(mode) {
+        this.details.mode = mode;
+        return true;
+    }
+}
+describe('VeSyncFan Base Class', () => {
+    let fan;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'Test Fan',
+            deviceType: 'Core300S',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'off',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAirBypass',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        fan = new TestVeSyncFan(deviceDetails, mockManager);
+    });
+    describe('Air Quality Getters', () => {
+        it('should return default values when air quality data is not available', () => {
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.pm1).toBe(0);
+            expect(fan.pm10).toBe(0);
+            expect(fan.aqPercent).toBe(0);
+            expect(fan.airQualityLevel).toBe('');
+        });
+        it('should return correct air quality values when data is available', () => {
+            fan.details.air_quality_value = 25;
+            fan.details.pm1 = 15;
+            fan.details.pm10 = 30;
+            fan.details.aq_percent = 80;
+            fan.details.air_quality = 'Good';
+            expect(fan.airQualityValue).toBe(25);
+            expect(fan.pm1).toBe(15);
+            expect(fan.pm10).toBe(30);
+            expect(fan.aqPercent).toBe(80);
+            expect(fan.airQualityLevel).toBe('Good');
+        });
+        it('should handle numeric air quality levels', () => {
+            fan.details.air_quality = 2;
+            expect(fan.airQualityLevel).toBe(2);
+        });
+        it('should maintain backward compatibility with airQuality getter', () => {
+            fan.details.air_quality = 'Excellent';
+            expect(fan.airQuality).toBe('Excellent');
+            expect(fan.airQuality).toBe(fan.airQualityLevel);
+        });
+        it('should handle extreme air quality values', () => {
+            fan.details.air_quality_value = 999;
+            fan.details.pm1 = 500;
+            fan.details.pm10 = 1000;
+            fan.details.aq_percent = 100;
+            expect(fan.airQualityValue).toBe(999);
+            expect(fan.pm1).toBe(500);
+            expect(fan.pm10).toBe(1000);
+            expect(fan.aqPercent).toBe(100);
+        });
+        it('should handle zero air quality values', () => {
+            fan.details.air_quality_value = 0;
+            fan.details.pm1 = 0;
+            fan.details.pm10 = 0;
+            fan.details.aq_percent = 0;
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.pm1).toBe(0);
+            expect(fan.pm10).toBe(0);
+            expect(fan.aqPercent).toBe(0);
+        });
+    });
+    describe('Filter Life Handling', () => {
+        it('should return 0 when filter life is not available', () => {
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle number format filter life (VeSyncAirBypass)', () => {
+            fan.details.filter_life = 85;
+            expect(fan.filterLife).toBe(85);
+        });
+        it('should handle object format filter life (VeSyncAir131)', () => {
+            fan.details.filter_life = { percent: 72 };
+            expect(fan.filterLife).toBe(72);
+        });
+        it('should handle object format with missing percent property', () => {
+            fan.details.filter_life = { other: 'value' };
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle null filter life object', () => {
+            fan.details.filter_life = null;
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle undefined filter life', () => {
+            fan.details.filter_life = undefined;
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle zero filter life values', () => {
+            fan.details.filter_life = 0;
+            expect(fan.filterLife).toBe(0);
+            fan.details.filter_life = { percent: 0 };
+            expect(fan.filterLife).toBe(0);
+        });
+        it('should handle 100% filter life', () => {
+            fan.details.filter_life = 100;
+            expect(fan.filterLife).toBe(100);
+            fan.details.filter_life = { percent: 100 };
+            expect(fan.filterLife).toBe(100);
+        });
+        it('should handle invalid filter life formats gracefully', () => {
+            fan.details.filter_life = 'invalid';
+            expect(fan.filterLife).toBe(0);
+            fan.details.filter_life = [];
+            expect(fan.filterLife).toBe(0);
+        });
+    });
+    describe('Feature Detection', () => {
+        it('should detect air quality feature for supported devices', () => {
+            expect(fan.hasFeature('air_quality')).toBe(true);
+        });
+        it('should detect supported features based on device type', () => {
+            expect(fan.hasFeature('display')).toBe(true);
+            expect(fan.hasFeature('child_lock')).toBe(true);
+            expect(fan.hasFeature('night_light')).toBe(true);
+            expect(fan.hasFeature('timer')).toBe(true);
+            expect(fan.hasFeature('fan_speed')).toBe(true);
+            expect(fan.hasFeature('auto_mode')).toBe(true);
+            expect(fan.hasFeature('sleep_mode')).toBe(true);
+        });
+        it('should return false for unsupported features', () => {
+            expect(fan.hasFeature('unsupported_feature')).toBe(false);
+        });
+        it('should handle devices without configuration', () => {
+            const unknownDevice = new TestVeSyncFan({
+                deviceName: 'Unknown Device',
+                deviceType: 'UnknownType',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(unknownDevice.hasFeature('air_quality')).toBe(false);
+        });
+    });
+    describe('Feature Support in Current Mode', () => {
+        it('should support air quality in all modes', () => {
+            fan.details.mode = 'auto';
+            expect(fan.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+            fan.details.mode = 'manual';
+            expect(fan.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+            fan.details.mode = 'sleep';
+            expect(fan.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+        });
+        it('should disable display and child lock in sleep mode', () => {
+            fan.details.mode = 'sleep';
+            expect(fan.isFeatureSupportedInCurrentMode('display')).toBe(false);
+            expect(fan.isFeatureSupportedInCurrentMode('child_lock')).toBe(false);
+        });
+        it('should support display and child lock in other modes', () => {
+            fan.details.mode = 'auto';
+            expect(fan.isFeatureSupportedInCurrentMode('display')).toBe(true);
+            expect(fan.isFeatureSupportedInCurrentMode('child_lock')).toBe(true);
+            fan.details.mode = 'manual';
+            expect(fan.isFeatureSupportedInCurrentMode('display')).toBe(true);
+            expect(fan.isFeatureSupportedInCurrentMode('child_lock')).toBe(true);
+        });
+        it('should return false for unsupported features regardless of mode', () => {
+            fan.details.mode = 'auto';
+            expect(fan.isFeatureSupportedInCurrentMode('unsupported')).toBe(false);
+        });
+    });
+    describe('Device Capabilities', () => {
+        it('should return correct maximum fan speed', () => {
+            expect(fan.getMaxFanSpeed()).toBe(4); // Core300S has 4 speeds
+        });
+        it('should handle devices without speed levels configured', () => {
+            const deviceWithoutLevels = new TestVeSyncFan({
+                deviceName: 'Basic Device',
+                deviceType: 'UnknownType',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(deviceWithoutLevels.getMaxFanSpeed()).toBe(3); // Default fallback
+        });
+        it('should return current mode and speed', () => {
+            fan.details.mode = 'auto';
+            fan.details.speed = 3;
+            expect(fan.mode).toBe('auto');
+            expect(fan.speed).toBe(3);
+        });
+        it('should handle missing mode and speed', () => {
+            expect(fan.mode).toBe('');
+            expect(fan.speed).toBe(0);
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('should handle missing details object', () => {
+            const minimalFan = new TestVeSyncFan({
+                deviceName: 'Minimal Device',
+                deviceType: 'Core300S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            // Details should be initialized as empty object
+            expect(minimalFan.airQualityValue).toBe(0);
+            expect(minimalFan.filterLife).toBe(0);
+            expect(minimalFan.mode).toBe('');
+            expect(minimalFan.speed).toBe(0);
+        });
+        it('should handle null and undefined values gracefully', () => {
+            fan.details.air_quality_value = null;
+            fan.details.filter_life = null;
+            fan.details.mode = null;
+            fan.details.speed = null;
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.filterLife).toBe(0);
+            expect(fan.mode).toBe('');
+            expect(fan.speed).toBe(0);
+        });
+        it('should handle invalid data types', () => {
+            fan.details.air_quality_value = 'invalid';
+            fan.details.pm1 = 'invalid';
+            fan.details.pm10 = 'invalid';
+            fan.details.aq_percent = 'invalid';
+            fan.details.speed = 'invalid';
+            expect(fan.airQualityValue).toBe(0);
+            expect(fan.pm1).toBe(0);
+            expect(fan.pm10).toBe(0);
+            expect(fan.aqPercent).toBe(0);
+            expect(fan.speed).toBe(0);
+        });
+    });
+});

package/dist/lib/fans/air131.js

@@ -56,10 +56,11 @@ class VeSyncAir131 extends vesyncFan_1.VeSyncFan {
             this.details = {
                 mode: data.mode || 'manual', // Default to manual if not specified
                 speed: data.level || 0,
-                filterLife: data.filterLife || 0,
-                screenStatus: data.screenStatus || 'off',
-                childLock: data.childLock || false,
-                airQuality: data.airQuality || 'unknown',
+                filter_life: data.filterLife || data.filter_life || 0,
+                screen_status: data.screenStatus || 'off',
+                child_lock: data.childLock || false,
+                air_quality: data.airQuality || 'unknown',
+                air_quality_value: data.air_quality_value || 0,
                 active_time: data.activeTime || 0
             };
             // Store last known speed when device is on and has a valid speed

package/dist/lib/fans/airBypass.js

@@ -56,11 +56,19 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
                 this.details = {
                     mode: result.mode || '',
                     speed: result.level || 0,
-                    filterLife: result.filter_life || 0,
-                    screenStatus: result.display ? 'on' : 'off',
-                    childLock: result.child_lock || false,
-                    airQuality: result.air_quality || 0
+                    filter_life: result.filter_life || 0,
+                    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
                 };
+                // Capture additional air quality properties if available
+                if ('PM1' in result)
+                    this.details.pm1 = result.PM1;
+                if ('PM10' in result)
+                    this.details.pm10 = result.PM10;
+                if ('AQPercent' in result)
+                    this.details.aq_percent = result.AQPercent;
                 // Don't overwrite config as it contains features array
                 if (result.configuration) {
                     this.details.configuration = result.configuration;

package/dist/lib/vesyncFan.d.ts

@@ -18,10 +18,16 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
     protected details: {
         mode?: string;
         speed?: number;
-        filter_life?: number;
+        filter_life?: number | {
+            percent: number;
+        };
         screen_status?: 'on' | 'off';
         child_lock?: boolean;
-        air_quality?: string;
+        air_quality?: string | number;
+        air_quality_value?: number;
+        pm1?: number;
+        pm10?: number;
+        aq_percent?: number;
         humidity?: number;
         mist_level?: number;
         warm_level?: number;
@@ -73,9 +79,29 @@ export declare abstract class VeSyncFan extends VeSyncBaseDevice {
      */
     get childLock(): boolean;
     /**
-     * Get air quality (if supported)
+     * Get air quality level (if supported)
      */
-    get airQuality(): string;
+    get airQualityLevel(): string | number;
+    /**
+     * Get air quality (alias for airQualityLevel for backward compatibility)
+     */
+    get airQuality(): string | number;
+    /**
+     * Get air quality value - PM2.5 in μg/m³ (if supported)
+     */
+    get airQualityValue(): number;
+    /**
+     * Get PM1 value (if supported)
+     */
+    get pm1(): number;
+    /**
+     * Get PM10 value (if supported)
+     */
+    get pm10(): number;
+    /**
+     * Get air quality percentage (if supported)
+     */
+    get aqPercent(): number;
     /**
      * Get humidity level (if supported)
      */