tsvesync 1.0.46 → 1.0.47

package/dist/lib/vesync.d.ts

@@ -3,6 +3,16 @@
  */
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { Logger } from './logger';
+/**
+ * Device exclusion configuration
+ */
+export interface ExcludeConfig {
+    type?: string[];
+    model?: string[];
+    name?: string[];
+    namePattern?: string[];
+    id?: string[];
+}
 /**
  * VeSync Manager Class
  */
@@ -14,6 +24,7 @@ export declare class VeSync {
     private _devList;
     private _lastUpdateTs;
     private _inProcess;
+    private _excludeConfig;
     username: string;
     password: string;
     token: string | null;
@@ -37,8 +48,9 @@ export declare class VeSync {
      * @param redact - Optional redact mode flag
      * @param apiUrl - Optional API base URL override
      * @param customLogger - Optional custom logger implementation
+     * @param excludeConfig - Optional device exclusion configuration
      */
-    constructor(username: string, password: string, timeZone?: string, debug?: boolean, redact?: boolean, apiUrl?: string, customLogger?: Logger);
+    constructor(username: string, password: string, timeZone?: string, debug?: boolean, redact?: boolean, apiUrl?: string, customLogger?: Logger, excludeConfig?: ExcludeConfig);
     /**
      * Get/Set debug mode
      */
@@ -70,6 +82,10 @@ export declare class VeSync {
      * Correct devices without cid or uuid
      */
     static setDevId(devices: any[]): any[];
+    /**
+     * Check if a device should be excluded based on configuration
+     */
+    private shouldExcludeDevice;
     /**
      * Process devices from API response
      */
@@ -88,9 +104,8 @@ export declare class VeSync {
     deviceTimeCheck(): boolean;
     /**
      * Update device list and details
-     * @param excludeDevices - Optional array of device IDs to exclude from detail updates
      */
-    update(excludeDevices?: string[]): Promise<void>;
+    update(): Promise<void>;
     /**
      * Create device instance from details
      */

package/dist/lib/vesync.js

@@ -129,14 +129,16 @@ class VeSync {
      * @param redact - Optional redact mode flag
      * @param apiUrl - Optional API base URL override
      * @param customLogger - Optional custom logger implementation
+     * @param excludeConfig - Optional device exclusion configuration
      */
-    constructor(username, password, timeZone = helpers_1.DEFAULT_TZ, debug = false, redact = true, apiUrl, customLogger) {
+    constructor(username, password, timeZone = helpers_1.DEFAULT_TZ, debug = false, redact = true, apiUrl, customLogger, excludeConfig) {
         this._debug = debug;
         this._redact = redact;
         this._energyUpdateInterval = DEFAULT_ENERGY_UPDATE_INTERVAL;
         this._energyCheck = true;
         this._lastUpdateTs = null;
         this._inProcess = false;
+        this._excludeConfig = excludeConfig || null;
         this.username = username;
         this.password = password;
         this.token = null;
@@ -283,6 +285,52 @@ class VeSync {
         }
         return devices;
     }
+    /**
+     * Check if a device should be excluded based on configuration
+     */
+    shouldExcludeDevice(device) {
+        var _a, _b, _c, _d, _e;
+        if (!this._excludeConfig) {
+            return false;
+        }
+        const exclude = this._excludeConfig;
+        // Check device type
+        if ((_a = exclude.type) === null || _a === void 0 ? void 0 : _a.includes(device.deviceType.toLowerCase())) {
+            logger_1.logger.debug(`Excluding device ${device.deviceName} by type: ${device.deviceType}`);
+            return true;
+        }
+        // Check device model
+        if ((_b = exclude.model) === null || _b === void 0 ? void 0 : _b.some(model => device.deviceType.toUpperCase().includes(model.toUpperCase()))) {
+            logger_1.logger.debug(`Excluding device ${device.deviceName} by model: ${device.deviceType}`);
+            return true;
+        }
+        // Check exact name match
+        if ((_c = exclude.name) === null || _c === void 0 ? void 0 : _c.includes(device.deviceName.trim())) {
+            logger_1.logger.debug(`Excluding device ${device.deviceName} by exact name match`);
+            return true;
+        }
+        // Check name patterns
+        if (exclude.namePattern) {
+            for (const pattern of exclude.namePattern) {
+                try {
+                    const regex = new RegExp(pattern);
+                    if (regex.test(device.deviceName.trim())) {
+                        logger_1.logger.debug(`Excluding device ${device.deviceName} by name pattern: ${pattern}`);
+                        return true;
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.warn(`Invalid regex pattern in exclude config: ${pattern}`);
+                }
+            }
+        }
+        // Check device ID (cid or uuid)
+        if (((_d = exclude.id) === null || _d === void 0 ? void 0 : _d.includes(device.cid)) || ((_e = exclude.id) === null || _e === void 0 ? void 0 : _e.includes(device.uuid))) {
+            logger_1.logger.debug(`Excluding device ${device.deviceName} by ID: ${device.cid}/${device.uuid}`);
+            return true;
+        }
+        return false;
+    }
     /**
      * Process devices from API response
      */
@@ -298,6 +346,10 @@ class VeSync {
             }
             // Process each device
             deviceList.forEach(dev => {
+                // Check if device should be excluded
+                if (this.shouldExcludeDevice(dev)) {
+                    return;
+                }
                 const [category, device] = objectFactory(dev, this);
                 // Handle outdoor plug sub-devices
                 if (dev.deviceType === 'ESO15-TB' && dev.subDeviceNo) {
@@ -308,9 +360,12 @@ class VeSync {
                         subDeviceNo: dev.subDeviceNo,
                         isSubDevice: true,
                     };
-                    const [subCategory, subDevice] = objectFactory(subDeviceDetails, this);
-                    if (subDevice && subCategory in this._devList) {
-                        this._devList[subCategory].push(subDevice);
+                    // Check if sub-device should be excluded
+                    if (!this.shouldExcludeDevice(subDeviceDetails)) {
+                        const [subCategory, subDevice] = objectFactory(subDeviceDetails, this);
+                        if (subDevice && subCategory in this._devList) {
+                            this._devList[subCategory].push(subDevice);
+                        }
                     }
                 }
                 else if (device && category in this._devList) {
@@ -448,9 +503,8 @@ class VeSync {
     }
     /**
      * Update device list and details
-     * @param excludeDevices - Optional array of device IDs to exclude from detail updates
      */
-    async update(excludeDevices = []) {
+    async update() {
         if (this.deviceTimeCheck()) {
             if (!this.enabled) {
                 logger_1.logger.error('Not logged in to VeSync');
@@ -460,11 +514,6 @@ class VeSync {
             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) {
-                    // Skip excluded devices
-                    if (excludeDevices.includes(device.cid)) {
-                        logger_1.logger.debug(`Skipping update for excluded device ${device.deviceName} (${device.cid})`);
-                        continue;
-                    }
                     try {
                         await device.getDetails();
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsvesync",
-  "version": "1.0.46",
+  "version": "1.0.47",
   "description": "A TypeScript library for interacting with VeSync smart home devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib/vesync.ts

@@ -23,6 +23,17 @@ interface DeviceModules {
 // Device categories
 type DeviceCategory = 'fans' | 'outlets' | 'switches' | 'bulbs';
 
+/**
+ * Device exclusion configuration
+ */
+export interface ExcludeConfig {
+    type?: string[];
+    model?: string[];
+    name?: string[];
+    namePattern?: string[];
+    id?: string[];
+}
+
 /**
  * Create device instance based on type
  */
@@ -147,6 +158,7 @@ export class VeSync {
     private _devList: Record<string, VeSyncBaseDevice[]>;
     private _lastUpdateTs: number | null;
     private _inProcess: boolean;
+    private _excludeConfig: ExcludeConfig | null;
 
     username: string;
     password: string;
@@ -173,6 +185,7 @@ export class VeSync {
      * @param redact - Optional redact mode flag
      * @param apiUrl - Optional API base URL override
      * @param customLogger - Optional custom logger implementation
+     * @param excludeConfig - Optional device exclusion configuration
      */
     constructor(
         username: string,
@@ -181,7 +194,8 @@ export class VeSync {
         debug = false,
         redact = true,
         apiUrl?: string,
-        customLogger?: Logger
+        customLogger?: Logger,
+        excludeConfig?: ExcludeConfig
     ) {
         this._debug = debug;
         this._redact = redact;
@@ -189,6 +203,7 @@ export class VeSync {
         this._energyCheck = true;
         this._lastUpdateTs = null;
         this._inProcess = false;
+        this._excludeConfig = excludeConfig || null;
 
         this.username = username;
         this.password = password;
@@ -351,6 +366,58 @@ export class VeSync {
         return devices;
     }
 
+    /**
+     * Check if a device should be excluded based on configuration
+     */
+    private shouldExcludeDevice(device: Record<string, any>): boolean {
+        if (!this._excludeConfig) {
+            return false;
+        }
+
+        const exclude = this._excludeConfig;
+
+        // Check device type
+        if (exclude.type?.includes(device.deviceType.toLowerCase())) {
+            logger.debug(`Excluding device ${device.deviceName} by type: ${device.deviceType}`);
+            return true;
+        }
+
+        // Check device model
+        if (exclude.model?.some(model => device.deviceType.toUpperCase().includes(model.toUpperCase()))) {
+            logger.debug(`Excluding device ${device.deviceName} by model: ${device.deviceType}`);
+            return true;
+        }
+
+        // Check exact name match
+        if (exclude.name?.includes(device.deviceName.trim())) {
+            logger.debug(`Excluding device ${device.deviceName} by exact name match`);
+            return true;
+        }
+
+        // Check name patterns
+        if (exclude.namePattern) {
+            for (const pattern of exclude.namePattern) {
+                try {
+                    const regex = new RegExp(pattern);
+                    if (regex.test(device.deviceName.trim())) {
+                        logger.debug(`Excluding device ${device.deviceName} by name pattern: ${pattern}`);
+                        return true;
+                    }
+                } catch (error) {
+                    logger.warn(`Invalid regex pattern in exclude config: ${pattern}`);
+                }
+            }
+        }
+
+        // Check device ID (cid or uuid)
+        if (exclude.id?.includes(device.cid) || exclude.id?.includes(device.uuid)) {
+            logger.debug(`Excluding device ${device.deviceName} by ID: ${device.cid}/${device.uuid}`);
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Process devices from API response
      */
@@ -368,6 +435,11 @@ export class VeSync {
 
             // Process each device
             deviceList.forEach(dev => {
+                // Check if device should be excluded
+                if (this.shouldExcludeDevice(dev)) {
+                    return;
+                }
+
                 const [category, device] = objectFactory(dev, this);
                 // Handle outdoor plug sub-devices
                 if (dev.deviceType === 'ESO15-TB' && dev.subDeviceNo) {
@@ -378,9 +450,12 @@ export class VeSync {
                         subDeviceNo: dev.subDeviceNo,
                         isSubDevice: true,
                     };
-                    const [subCategory, subDevice] = objectFactory(subDeviceDetails, this);
-                    if (subDevice && subCategory in this._devList) {
-                        this._devList[subCategory].push(subDevice);
+                    // Check if sub-device should be excluded
+                    if (!this.shouldExcludeDevice(subDeviceDetails)) {
+                        const [subCategory, subDevice] = objectFactory(subDeviceDetails, this);
+                        if (subDevice && subCategory in this._devList) {
+                            this._devList[subCategory].push(subDevice);
+                        }
                     }
                 } else if (device && category in this._devList) {
                     this._devList[category].push(device);
@@ -549,9 +624,8 @@ export class VeSync {
 
     /**
      * Update device list and details
-     * @param excludeDevices - Optional array of device IDs to exclude from detail updates
      */
-    async update(excludeDevices: string[] = []): Promise<void> {
+    async update(): Promise<void> {
         if (this.deviceTimeCheck()) {
             if (!this.enabled) {
                 logger.error('Not logged in to VeSync');
@@ -563,12 +637,6 @@ export class VeSync {
             logger.debug('Start updating the device details one by one');
             for (const deviceList of Object.values(this._devList)) {
                 for (const device of deviceList) {
-                    // Skip excluded devices
-                    if (excludeDevices.includes(device.cid)) {
-                        logger.debug(`Skipping update for excluded device ${device.deviceName} (${device.cid})`);
-                        continue;
-                    }
-                    
                     try {
                         await device.getDetails();
                     } catch (error) {