tsvesync 1.0.11 → 1.0.13

package/dist/lib/vesync.js

@@ -1,104 +1,116 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VeSync = void 0;
 /**
  * VeSync API Device Library
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSync = void 0;
 const helpers_1 = require("./helpers");
-const bulbMods = __importStar(require("./vesyncBulb"));
-const fanMods = __importStar(require("./vesyncFan"));
-const outletMods = __importStar(require("./vesyncOutlet"));
-const switchMods = __importStar(require("./vesyncSwitch"));
-const kitchenMods = __importStar(require("./vesyncKitchen"));
+const vesyncFanImpl_1 = require("./vesyncFanImpl");
+const vesyncOutletImpl_1 = require("./vesyncOutletImpl");
+const vesyncSwitchImpl_1 = require("./vesyncSwitchImpl");
+const vesyncBulbImpl_1 = require("./vesyncBulbImpl");
+const logger_1 = require("./logger");
 const DEFAULT_ENERGY_UPDATE_INTERVAL = 21600;
-function objectFactory(devType, config, manager) {
-    const fans = (devType, config, manager) => {
-        const fanCls = fanMods.fanModules[devType];
-        return ['fans', new fanCls(config, manager)];
-    };
-    const outlets = (devType, config, manager) => {
-        const outletCls = outletMods.outletModules[devType];
-        return ['outlets', new outletCls(config, manager)];
-    };
-    const switches = (devType, config, manager) => {
-        const switchCls = switchMods.switchModules[devType];
-        return ['switches', new switchCls(config, manager)];
-    };
-    const bulbs = (devType, config, manager) => {
-        const bulbCls = bulbMods.bulbModules[devType];
-        return ['bulbs', new bulbCls(config, manager)];
-    };
-    const kitchen = (devType, config, manager) => {
-        const kitchenCls = kitchenMods.kitchenModules[devType];
-        return ['kitchen', new kitchenCls(config, manager)];
+/**
+ * Create device instance based on type
+ */
+function objectFactory(details, manager) {
+    const deviceType = details.deviceType;
+    let DeviceClass = null;
+    let category = 'unknown';
+    // Map of device categories to their module dictionaries
+    const allModules = {
+        outlets: vesyncOutletImpl_1.outletModules,
+        fans: vesyncFanImpl_1.fanModules,
+        bulbs: vesyncBulbImpl_1.bulbModules,
+        switches: vesyncSwitchImpl_1.switchModules
     };
-    if (devType in fanMods.fanModules) {
-        return fans(devType, config, manager);
-    }
-    else if (devType in outletMods.outletModules) {
-        return outlets(devType, config, manager);
-    }
-    else if (devType in switchMods.switchModules) {
-        return switches(devType, config, manager);
+    // First try exact match in all modules
+    for (const [cat, modules] of Object.entries(allModules)) {
+        if (deviceType in modules) {
+            DeviceClass = modules[deviceType];
+            category = cat;
+            logger_1.logger.debug(`Found exact match for ${deviceType} in ${cat} modules`);
+            break;
+        }
     }
-    else if (devType in bulbMods.bulbModules) {
-        return bulbs(devType, config, manager);
+    // If no exact match, try to find a base class
+    if (!DeviceClass) {
+        // Device type prefix mapping
+        const prefixMap = {
+            // Fans
+            'Core': 'fans',
+            'LAP': 'fans',
+            'LTF': 'fans',
+            'Classic': 'fans',
+            'Dual': 'fans',
+            'LUH': 'fans',
+            'LEH': 'fans',
+            'LV-PUR': 'fans',
+            'LV-RH': 'fans',
+            // Outlets
+            'wifi-switch': 'outlets',
+            'ESW03': 'outlets',
+            'ESW01': 'outlets',
+            'ESW15': 'outlets',
+            'ESO': 'outlets',
+            // Switches
+            'ESWL': 'switches',
+            'ESWD': 'switches',
+            // Bulbs
+            'ESL': 'bulbs',
+            'XYD': 'bulbs'
+        };
+        // Find category based on device type prefix
+        for (const [prefix, cat] of Object.entries(prefixMap)) {
+            if (deviceType.startsWith(prefix)) {
+                category = cat;
+                logger_1.logger.debug(`Device type ${deviceType} matched prefix ${prefix} -> category ${cat}`);
+                // Try to find a base class in this category's modules
+                const modules = allModules[cat];
+                for (const [moduleType, ModuleClass] of Object.entries(modules)) {
+                    const baseType = moduleType.split('-')[0]; // e.g., ESL100 from ESL100-USA
+                    if (deviceType.startsWith(baseType)) {
+                        DeviceClass = ModuleClass;
+                        logger_1.logger.debug(`Found base type match: ${deviceType} -> ${baseType}`);
+                        break;
+                    }
+                }
+                break;
+            }
+        }
     }
-    else if (devType in kitchenMods.kitchenModules) {
-        return kitchen(devType, config, manager);
+    if (DeviceClass) {
+        try {
+            // Add category to device details
+            details.deviceCategory = category;
+            const device = new DeviceClass(details, manager);
+            return [category, device];
+        }
+        catch (error) {
+            logger_1.logger.error(`Error creating device instance for ${deviceType}:`, error);
+            return [category, null];
+        }
     }
     else {
-        console.debug('Unknown device named %s model %s', config.deviceName || '', config.deviceType || '');
-        return ['unknown', null];
+        logger_1.logger.warn(`No device class found for type: ${deviceType}`);
+        return [category, null];
     }
 }
+/**
+ * VeSync Manager Class
+ */
 class VeSync {
+    /**
+     * Initialize VeSync Manager
+     */
     constructor(username, password, timeZone = helpers_1.DEFAULT_TZ, debug = false, redact = true) {
-        this.body = helpers_1.Helpers.reqBody(this, 'devicelist');
-        this[_a] = await helpers_1.Helpers.callApi('/cloud/v1/deviceManaged/devices', 'post', body, helpers_1.Helpers.reqHeaders(this));
         this._debug = debug;
-        if (debug) {
-            // Set debug logging levels
-            console.debug('Debug logging enabled');
-        }
         this._redact = redact;
-        if (redact) {
-            helpers_1.Helpers.redact = redact;
-        }
+        this._energyUpdateInterval = DEFAULT_ENERGY_UPDATE_INTERVAL;
+        this._energyCheck = true;
+        this._lastUpdateTs = null;
+        this._inProcess = false;
         this.username = username;
         this.password = password;
         this.token = null;
@@ -107,29 +119,22 @@ class VeSync {
         this.devices = null;
         this.enabled = false;
         this.updateInterval = helpers_1.API_RATE_LIMIT;
-        this.lastUpdateTs = null;
-        this.inProcess = false;
-        this._energyUpdateInterval = DEFAULT_ENERGY_UPDATE_INTERVAL;
-        this._energyCheck = true;
         this.fans = [];
         this.outlets = [];
         this.switches = [];
         this.bulbs = [];
         this.scales = [];
-        this.kitchen = [];
         this._devList = {
             fans: this.fans,
             outlets: this.outlets,
             switches: this.switches,
-            bulbs: this.bulbs,
-            kitchen: this.kitchen,
-            unknown: []
+            bulbs: this.bulbs
         };
         if (typeof timeZone === 'string' && timeZone) {
             const regTest = /[^a-zA-Z/_]/;
             if (regTest.test(timeZone)) {
                 this.timeZone = helpers_1.DEFAULT_TZ;
-                console.debug('Invalid characters in time zone - %s', timeZone);
+                logger_1.logger.debug('Invalid characters in time zone - ', timeZone);
             }
             else {
                 this.timeZone = timeZone;
@@ -137,41 +142,47 @@ class VeSync {
         }
         else {
             this.timeZone = helpers_1.DEFAULT_TZ;
-            console.debug('Time zone is not a string');
+            logger_1.logger.debug('Time zone is not a string');
+        }
+        if (debug) {
+            this.debug = true;
+        }
+        if (redact) {
+            this.redact = true;
         }
     }
+    /**
+     * Get/Set debug mode
+     */
     get debug() {
         return this._debug;
     }
-    set debug(newFlag) {
-        this._debug = newFlag;
-        // Set logging levels based on debug flag
-        if (newFlag) {
-            console.debug('Debug logging enabled');
-        }
+    set debug(flag) {
+        this._debug = flag;
     }
+    /**
+     * Get/Set redact mode
+     */
     get redact() {
         return this._redact;
     }
-    set redact(newFlag) {
-        if (newFlag) {
-            helpers_1.Helpers.redact = true;
-        }
-        else {
-            helpers_1.Helpers.redact = false;
-        }
-        this._redact = newFlag;
+    set redact(flag) {
+        this._redact = flag;
+        helpers_1.Helpers.shouldRedact = flag;
     }
+    /**
+     * Get/Set energy update interval
+     */
     get energyUpdateInterval() {
         return this._energyUpdateInterval;
     }
-    set energyUpdateInterval(newEnergyUpdate) {
-        if (newEnergyUpdate > 0) {
-            this._energyUpdateInterval = newEnergyUpdate;
+    set energyUpdateInterval(interval) {
+        if (interval > 0) {
+            this._energyUpdateInterval = interval;
         }
     }
     /**
-     * Test if device should be removed - false = Remove
+     * Test if device should be removed
      */
     static removeDevTest(device, newList) {
         if (Array.isArray(newList) && device.cid) {
@@ -180,130 +191,243 @@ class VeSync {
                     return true;
                 }
             }
+            logger_1.logger.debug(`Device removed - ${device.deviceName} - ${device.deviceType}`);
+            return false;
         }
-        return false;
+        return true;
     }
     /**
-     * Login to VeSync server
+     * Test if new device should be added
      */
-    async login() {
-        const body = helpers_1.Helpers.reqBody(this, 'login');
-        const [response] = await helpers_1.Helpers.callApi('/cloud/v1/user/login', 'post', body);
-        if (!response || response.code !== 0 || !response.result) {
-            console.error('Error logging in to VeSync');
-            return false;
+    addDevTest(newDev) {
+        if ('cid' in newDev) {
+            for (const devices of Object.values(this._devList)) {
+                for (const dev of devices) {
+                    if (dev.cid === newDev.cid) {
+                        return false;
+                    }
+                }
+            }
         }
-        this.token = response.result.token;
-        this.accountId = response.result.accountID;
-        this.countryCode = response.result.countryCode;
-        this.enabled = true;
         return true;
     }
     /**
-     * Get list of VeSync devices
+     * Remove devices not found in device list return
      */
-    async getDevices() {
-        if (!this.enabled)
-            : console.error('Not logged in');
-        return false;
+    removeOldDevices(devices) {
+        for (const [key, deviceList] of Object.entries(this._devList)) {
+            const before = deviceList.length;
+            this._devList[key] = deviceList.filter(device => VeSync.removeDevTest(device, devices));
+            const after = this._devList[key].length;
+            if (before !== after) {
+                logger_1.logger.debug(`${before - after} ${key} removed`);
+            }
+        }
+        return true;
     }
-    if(, response) { }
-}
-exports.VeSync = VeSync;
-_a = response;
- || response.code !== 0;
-{
-    console.error('Error getting device list');
-    return false;
-}
-this.devices = response.result.list || [];
-return true;
-/**
- * Process devices after getting list of devices
- */
-processDevices();
-void {
-    : .devices
-};
-{
-    console.error('Device list not fetched');
-    return;
-}
-const deviceList = [...this.devices];
-const toRemove = [];
-// Build list of devices to remove
-for (const devList of Object.values(this._devList)) {
-    for (const device of devList) {
-        if (!VeSync.removeDevTest(device, deviceList)) {
-            toRemove.push(device);
+    /**
+     * Correct devices without cid or uuid
+     */
+    static setDevId(devices) {
+        const devRem = [];
+        devices.forEach((dev, index) => {
+            if (!dev.cid) {
+                if (dev.macID) {
+                    dev.cid = dev.macID;
+                }
+                else if (dev.uuid) {
+                    dev.cid = dev.uuid;
+                }
+                else {
+                    devRem.push(index);
+                    logger_1.logger.warn(`Device with no ID - ${dev.deviceName || ''}`);
+                }
+            }
+        });
+        if (devRem.length > 0) {
+            return devices.filter((_, index) => !devRem.includes(index));
         }
+        return devices;
     }
-}
-// Remove devices not in device list
-for (const device of toRemove) {
-    for (const [key, devList] of Object.entries(this._devList)) {
-        const index = devList.indexOf(device);
-        if (index > -1) {
-            this._devList[key].splice(index, 1);
+    /**
+     * Process device list and instantiate device objects
+     */
+    processDevices(devList) {
+        // Ensure devices have proper IDs
+        const devices = VeSync.setDevId(devList);
+        // Count current devices
+        let numDevices = 0;
+        for (const deviceList of Object.values(this._devList)) {
+            numDevices += deviceList.length;
+        }
+        if (!devices || devices.length === 0) {
+            logger_1.logger.warn('No devices found in api return');
+            return false;
+        }
+        // Initialize new device list or remove old devices
+        if (numDevices === 0) {
+            logger_1.logger.debug('New device list initialized');
+        }
+        else {
+            this.removeOldDevices(devices);
         }
+        // Filter out devices that already exist
+        const newDevices = devices.filter(dev => this.addDevTest(dev));
+        // Required keys for device instantiation
+        const requiredKeys = ['deviceType', 'deviceName', 'deviceStatus', 'cid'];
+        // Process each new device
+        for (const dev of newDevices) {
+            // Verify required device properties
+            if (!requiredKeys.every(key => key in dev)) {
+                logger_1.logger.debug(`Error adding device - missing required properties: ${dev.deviceName || 'Unknown'}`);
+                continue;
+            }
+            const devType = dev.deviceType;
+            try {
+                // Create device instance using factory
+                const [category, deviceObj] = objectFactory(dev, this);
+                // Add device to appropriate category if valid
+                if (deviceObj && category in this._devList) {
+                    this._devList[category].push(deviceObj);
+                    logger_1.logger.debug(`Added ${devType} device to ${category} category`);
+                }
+                else if (category === 'unknown') {
+                    logger_1.logger.debug(`Unknown device type: ${devType}`);
+                }
+            }
+            catch (err) {
+                logger_1.logger.error(`Error creating device ${devType}:`, err);
+                continue;
+            }
+        }
+        return true;
     }
-}
-// Add new devices
-for (const device of deviceList) {
-    let foundDevice = false;
-    // Look for existing devices
-    for (const devList of Object.values(this._devList)) {
-        if (devList.some(dev => dev.cid === device.cid)) {
-            foundDevice = true;
-            break;
+    /**
+     * Get list of VeSync devices
+     */
+    async getDevices() {
+        var _a, _b;
+        if (!this.enabled) {
+            logger_1.logger.error('Not logged in to VeSync');
+            return false;
+        }
+        this._inProcess = true;
+        let procReturn = false;
+        try {
+            const [response] = await helpers_1.Helpers.callApi('/cloud/v2/deviceManaged/devices', 'post', helpers_1.Helpers.reqBody(this, 'devicelist'), helpers_1.Helpers.reqHeaders(this));
+            if ((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.list) {
+                const deviceList = response.result.list;
+                procReturn = this.processDevices(deviceList);
+                // Update the main devices array with all devices
+                this.devices = Object.values(this._devList).flat();
+                // Log device discovery results
+                logger_1.logger.debug('\n=== Device Discovery Summary ===');
+                logger_1.logger.debug(`Total devices processed: ${deviceList.length}`);
+                // Log device types found
+                const deviceTypes = deviceList.map((d) => d.deviceType);
+                logger_1.logger.debug('\nDevice types found:', deviceTypes);
+                // Log devices by category with details
+                logger_1.logger.debug('\nDevices by Category:');
+                logger_1.logger.debug('---------------------');
+                for (const [category, devices] of Object.entries(this._devList)) {
+                    if (devices.length > 0) {
+                        logger_1.logger.debug(`\n${category.toUpperCase()} (${devices.length} devices):`);
+                        devices.forEach((d) => {
+                            logger_1.logger.debug(`  • ${d.deviceName}`);
+                            logger_1.logger.debug(`    Type: ${d.deviceType}`);
+                            logger_1.logger.debug(`    Status: ${d.deviceStatus}`);
+                            logger_1.logger.debug(`    ID: ${d.cid}`);
+                        });
+                    }
+                }
+                // Log summary statistics
+                logger_1.logger.debug('\nSummary Statistics:');
+                logger_1.logger.debug('-------------------');
+                logger_1.logger.debug(`Total Devices: ${((_b = this.devices) === null || _b === void 0 ? void 0 : _b.length) || 0}`);
+                for (const [category, devices] of Object.entries(this._devList)) {
+                    logger_1.logger.debug(`${category}: ${devices.length} devices`);
+                }
+                logger_1.logger.debug('\n=== End of Device Discovery ===\n');
+            }
+            else {
+                logger_1.logger.error('No devices found in response');
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Unable to get device list:', error);
         }
+        this._inProcess = false;
+        return procReturn;
     }
-    // If device not found, add it
-    if (!foundDevice) {
-        const [deviceType, deviceObj] = objectFactory(device.deviceType, device, this);
-        if (deviceObj) {
-            this._devList[deviceType].push(deviceObj);
+    /**
+     * Login to VeSync server
+     */
+    async login() {
+        var _a;
+        const body = helpers_1.Helpers.reqBody(this, 'login');
+        logger_1.logger.debug('Login request:', {
+            url: `${process.env.VESYNC_API_URL}/cloud/v1/user/login`,
+            body
+        });
+        try {
+            const [response, status] = await helpers_1.Helpers.callApi('/cloud/v1/user/login', 'post', body);
+            logger_1.logger.debug('Login response:', { status, response });
+            if ((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.token) {
+                this.token = response.result.token;
+                this.accountId = response.result.accountID;
+                this.countryCode = response.result.countryCode;
+                this.enabled = true;
+                return true;
+            }
+            logger_1.logger.error('Unable to login with supplied credentials');
+            return false;
+        }
+        catch (error) {
+            logger_1.logger.error('Login error:', error);
+            return false;
         }
     }
-}
-/**
- * Update all devices
- */
-async;
-update();
-Promise < void  > {
-    : .enabled
-};
-{
-    console.error('Not logged in');
-    return;
-}
-if (this.inProcess) {
-    console.debug('Update already in process');
-    return;
-}
-const currentTime = Date.now();
-if (this.lastUpdateTs &&
-    currentTime - this.lastUpdateTs < this.updateInterval * 1000) {
-    console.debug('Update rate limit - waiting %d seconds', this.updateInterval - (currentTime - this.lastUpdateTs) / 1000);
-    return;
-}
-this.inProcess = true;
-this.lastUpdateTs = currentTime;
-try {
-    await this.getDevices();
-    this.processDevices();
-    const updatePromises = [];
-    for (const deviceList of Object.values(this._devList)) {
-        for (const device of deviceList) {
-            if ('update' in device && typeof device.update === 'function') {
-                updatePromises.push(device.update());
+    /**
+     * Test if update interval has been exceeded
+     */
+    deviceTimeCheck() {
+        return (this._lastUpdateTs === null ||
+            (Date.now() - this._lastUpdateTs) / 1000 > this.updateInterval);
+    }
+    /**
+     * Update device list and details
+     */
+    async update() {
+        if (this.deviceTimeCheck()) {
+            if (!this.enabled) {
+                logger_1.logger.error('Not logged in to VeSync');
+                return;
             }
+            await this.getDevices();
+            logger_1.logger.debug('Start updating the device details one by one');
+            for (const deviceList of Object.values(this._devList)) {
+                for (const device of deviceList) {
+                    try {
+                        await device.getDetails();
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`Error updating ${device.deviceName}:`, error);
+                    }
+                }
+            }
+            this._lastUpdateTs = Date.now();
         }
     }
-    await Promise.all(updatePromises);
-}
-finally {
-    this.inProcess = false;
+    /**
+     * Create device instance from details
+     */
+    createDevice(details) {
+        const deviceType = details.deviceType;
+        const deviceClass = vesyncFanImpl_1.fanModules[deviceType];
+        if (deviceClass) {
+            return new deviceClass(details, this);
+        }
+        return null;
+    }
 }
-//# sourceMappingURL=vesync.js.map
+exports.VeSync = VeSync;