tsvesync 1.0.89 → 1.0.91

package/README.md

@@ -201,42 +201,7 @@ The library supports configuration through environment variables:
 ```env
 VESYNC_USERNAME=your_email@example.com
 VESYNC_PASSWORD=your_password
-VESYNC_API_URL=https://smartapi.vesync.com  # Optional, auto-detects regional endpoint
-```
-
-### Regional API Support
-
-The library automatically detects the correct regional API endpoint based on your timezone:
-
-- **Europe**: `https://smartapi.vesync.eu` (for European timezones like `Europe/Berlin`, `Europe/London`)
-- **Asia**: `https://smartapi.vesync.com.cn` (for Asian timezones like `Asia/Shanghai`, `Asia/Tokyo`)
-- **US/Others**: `https://smartapi.vesync.com` (default for all other timezones)
-
-**For German users experiencing authentication issues:**
-
-```typescript
-// This will automatically use the EU API endpoint
-const manager = new VeSync(
-    'your_email@example.com',
-    'your_password', 
-    'Europe/Berlin'  // This triggers EU endpoint selection
-);
-
-await manager.login();
-```
-
-**Manual API endpoint override:**
-
-```typescript
-// Force a specific regional endpoint
-const manager = new VeSync(
-    'your_email@example.com',
-    'your_password',
-    'Europe/Berlin',
-    false, // debug
-    true,  // redact
-    'https://smartapi.vesync.eu'  // Force EU endpoint
-);
+VESYNC_API_URL=https://smartapi.vesync.com  # Optional, defaults to standard API URL
 ```
 
 ## Testing

package/dist/__tests__/fans/vesyncAir131.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncAir131 air quality data parsing and filter life handling
+ */
+export {};

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

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * Unit tests for VeSyncAir131 air quality data parsing and filter life handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const air131_1 = require("../../lib/fans/air131");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+describe('VeSyncAir131 Air Quality Features', () => {
+    let device;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'LV-PUR131S Test',
+            deviceType: 'LV-PUR131S',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'on',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAir131',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        device = new air131_1.VeSyncAir131(deviceDetails, mockManager);
+    });
+    describe('Air Quality Data Parsing', () => {
+        it('should parse air quality data with PM2.5 values', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 2,
+                        speed: 2,
+                        display: true,
+                        child_lock: false,
+                        night_light: 'off',
+                        air_quality: 2,
+                        air_quality_value: 28,
+                        filter_life: {
+                            percent: 68,
+                            replace_indicator: false
+                        },
+                        timer_remain: 0
+                    }
+                }
+            };
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(28);
+            expect(device.filterLife).toBe(68);
+        });
+        it('should handle air quality levels 1-5 mapping', () => {
+            const airQualityMappings = [
+                { level: 1, pm25: 8, description: 'Excellent' },
+                { level: 2, pm25: 22, description: 'Good' },
+                { level: 3, pm25: 38, description: 'Fair' },
+                { level: 4, pm25: 75, description: 'Poor' },
+                { level: 5, pm25: 150, description: 'Very Poor' }
+            ];
+            airQualityMappings.forEach(mapping => {
+                device.details = {
+                    air_quality: mapping.level,
+                    air_quality_value: mapping.pm25,
+                    filter_life: { percent: 50 }
+                };
+                expect(device.airQualityLevel).toBe(mapping.level);
+                expect(device.airQualityValue).toBe(mapping.pm25);
+            });
+        });
+        it('should handle missing air quality data', () => {
+            device.details = {
+                enabled: true,
+                mode: 'manual',
+                level: 3,
+                speed: 3,
+                filter_life: { percent: 45 }
+                // air_quality and air_quality_value missing
+            };
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+        });
+        it('should handle zero PM2.5 readings (perfect air)', () => {
+            device.details = {
+                air_quality: 1,
+                air_quality_value: 0,
+                filter_life: { percent: 85 }
+            };
+            expect(device.airQualityLevel).toBe(1);
+            expect(device.airQualityValue).toBe(0);
+        });
+        it('should handle hazardous air quality levels', () => {
+            device.details = {
+                air_quality: 5,
+                air_quality_value: 500,
+                filter_life: { percent: 25 }
+            };
+            expect(device.airQualityLevel).toBe(5);
+            expect(device.airQualityValue).toBe(500);
+        });
+    });
+    describe('Filter Life Object Format', () => {
+        it('should parse filter life object with percent', () => {
+            device.details = {
+                filter_life: {
+                    percent: 72,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(72);
+        });
+        it('should handle filter replacement indicator', () => {
+            device.details = {
+                filter_life: {
+                    percent: 8,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(8);
+        });
+        it('should handle new filter (100%)', () => {
+            device.details = {
+                filter_life: {
+                    percent: 100,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(100);
+        });
+        it('should handle filter needs replacement (0%)', () => {
+            device.details = {
+                filter_life: {
+                    percent: 0,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle missing percent in filter object', () => {
+            device.details = {
+                filter_life: {
+                    replace_indicator: true
+                    // percent missing
+                }
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle null filter life object', () => {
+            device.details = {
+                filter_life: null
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle empty filter life object', () => {
+            device.details = {
+                filter_life: {}
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle malformed filter life object', () => {
+            device.details = {
+                filter_life: {
+                    percent: 'not_a_number',
+                    replace_indicator: 'not_a_boolean'
+                }
+            };
+            expect(device.filterLife).toBe(0);
+        });
+    });
+    describe('Device Configuration and Features', () => {
+        it('should support air quality features for LV-PUR131S', () => {
+            expect(device.hasFeature('air_quality')).toBe(true);
+            expect(device.hasFeature('display')).toBe(true);
+            expect(device.hasFeature('child_lock')).toBe(true);
+            expect(device.hasFeature('night_light')).toBe(true);
+            expect(device.hasFeature('timer')).toBe(true);
+            expect(device.hasFeature('fan_speed')).toBe(true);
+            expect(device.hasFeature('auto_mode')).toBe(true);
+        });
+        it('should return correct maximum speed for LV-PUR131S', () => {
+            expect(device.getMaxFanSpeed()).toBe(3); // LV series has 3 speeds
+        });
+        it('should handle LV-RH131S without air quality', () => {
+            const rh131s = new air131_1.VeSyncAir131({
+                deviceName: 'LV-RH131S Test',
+                deviceType: 'LV-RH131S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(rh131s.hasFeature('air_quality')).toBe(false);
+            expect(rh131s.hasFeature('display')).toBe(true);
+        });
+    });
+    describe('Mode-specific Behavior', () => {
+        it('should support air quality in auto mode', () => {
+            device.details.mode = 'auto';
+            expect(device.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+        });
+        it('should support air quality in manual mode', () => {
+            device.details.mode = 'manual';
+            expect(device.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+        });
+        it('should restrict fan speed control to manual mode', () => {
+            device.details.mode = 'manual';
+            expect(device.isFeatureSupportedInCurrentMode('fan_speed')).toBe(true);
+            device.details.mode = 'auto';
+            expect(device.isFeatureSupportedInCurrentMode('fan_speed')).toBe(false);
+        });
+        it('should disable display and child lock in sleep mode', () => {
+            device.details.mode = 'sleep';
+            expect(device.isFeatureSupportedInCurrentMode('display')).toBe(false);
+            expect(device.isFeatureSupportedInCurrentMode('child_lock')).toBe(false);
+        });
+    });
+    describe('State Tracking and Updates', () => {
+        it('should track complete device state', () => {
+            device.details = {
+                enabled: true,
+                mode: 'auto',
+                level: 2,
+                speed: 2,
+                display: true,
+                child_lock: false,
+                night_light: 'dim',
+                air_quality: 2,
+                air_quality_value: 32,
+                filter_life: {
+                    percent: 55,
+                    replace_indicator: false
+                },
+                timer_remain: 1800
+            };
+            expect(device.deviceStatus).toBe('on');
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(2);
+            expect(device.screenStatus).toBe('on'); // display: true maps to 'on'
+            expect(device.childLock).toBe(false);
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(32);
+            expect(device.filterLife).toBe(55);
+        });
+        it('should handle boolean display values correctly', () => {
+            device.details = { display: true };
+            expect(device.screenStatus).toBe('on');
+            device.details = { display: false };
+            expect(device.screenStatus).toBe('off');
+        });
+        it('should track filter replacement warnings', () => {
+            // Filter life getting low
+            device.details = {
+                filter_life: {
+                    percent: 15,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(15);
+            // Filter replacement needed
+            device.details = {
+                filter_life: {
+                    percent: 5,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(5);
+        });
+    });
+    describe('Air Quality History and Trends', () => {
+        it('should handle air quality improvements', () => {
+            // Poor air quality initially
+            device.details = {
+                air_quality: 4,
+                air_quality_value: 85,
+                filter_life: { percent: 40 }
+            };
+            expect(device.airQualityLevel).toBe(4);
+            // Air quality improves
+            device.details.air_quality = 2;
+            device.details.air_quality_value = 25;
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(25);
+        });
+        it('should handle air quality deterioration', () => {
+            // Good air quality initially
+            device.details = {
+                air_quality: 2,
+                air_quality_value: 20,
+                filter_life: { percent: 60 }
+            };
+            expect(device.airQualityLevel).toBe(2);
+            // Air quality worsens
+            device.details.air_quality = 4;
+            device.details.air_quality_value = 90;
+            expect(device.airQualityLevel).toBe(4);
+            expect(device.airQualityValue).toBe(90);
+        });
+    });
+    describe('Error Handling and Edge Cases', () => {
+        it('should handle completely missing details', () => {
+            device.details = undefined;
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle partial API responses', () => {
+            device.details = {
+                mode: 'auto',
+                speed: 1
+                // All other fields missing
+            };
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(1);
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle network errors gracefully', () => {
+            // Simulate network error - details remain from last update
+            device.details = {
+                air_quality: 2,
+                air_quality_value: 30,
+                filter_life: { percent: 70 }
+            };
+            // Values preserved from last successful update
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(30);
+            expect(device.filterLife).toBe(70);
+        });
+        it('should handle invalid air quality levels', () => {
+            device.details = {
+                air_quality: 10, // Invalid level (should be 1-5)
+                air_quality_value: 50,
+                filter_life: { percent: 50 }
+            };
+            expect(device.airQualityLevel).toBe(10); // Return raw value for debugging
+            expect(device.airQualityValue).toBe(50);
+        });
+        it('should handle negative filter life percent', () => {
+            device.details = {
+                filter_life: {
+                    percent: -10,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(-10); // Allow for error detection
+        });
+        it('should handle filter life percent over 100', () => {
+            device.details = {
+                filter_life: {
+                    percent: 150,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(150); // Allow for error detection
+        });
+    });
+});

package/dist/__tests__/fans/vesyncAirBaseV2.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncAirBaseV2 air quality data parsing
+ */
+export {};