tsvesync 1.0.46 → 1.0.48

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
      */
@@ -86,11 +98,14 @@ export declare class VeSync {
      * Test if update interval has been exceeded
      */
     deviceTimeCheck(): boolean;
+    /**
+     * Check if a device should be excluded based on configuration
+     */
+    private shouldExcludeDevice;
     /**
      * 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;
@@ -446,11 +448,56 @@ class VeSync {
         return (this._lastUpdateTs === null ||
             (Date.now() - this._lastUpdateTs) / 1000 > this.updateInterval);
     }
+    /**
+     * 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;
+    }
     /**
      * 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,13 +507,13 @@ 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();
+                        if (!this.shouldExcludeDevice(device)) {
+                            await device.getDetails();
+                        }
+                        else {
+                            logger_1.logger.debug(`Skipping details update for excluded device: ${device.deviceName}`);
+                        }
                     }
                     catch (error) {
                         logger_1.logger.error(`Error updating ${device.deviceName}:`, error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsvesync",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "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

@@ -12,6 +12,17 @@ import { logger, setLogger, Logger } from './logger';
 
 const DEFAULT_ENERGY_UPDATE_INTERVAL = 21600;
 
+/**
+ * Device exclusion configuration
+ */
+export interface ExcludeConfig {
+    type?: string[];
+    model?: string[];
+    name?: string[];
+    namePattern?: string[];
+    id?: string[];
+}
+
 // Device constructor type for concrete device classes only
 type DeviceConstructor = new (config: Record<string, any>, manager: VeSync) => VeSyncBaseDevice;
 
@@ -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;
@@ -547,11 +562,62 @@ export class VeSync {
         );
     }
 
+    /**
+     * Check if a device should be excluded based on configuration
+     */
+    private shouldExcludeDevice(device: VeSyncBaseDevice): 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;
+    }
+
     /**
      * 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,14 +629,12 @@ 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();
+                        if (!this.shouldExcludeDevice(device)) {
+                            await device.getDetails();
+                        } else {
+                            logger.debug(`Skipping details update for excluded device: ${device.deviceName}`);
+                        }
                     } catch (error) {
                         logger.error(`Error updating ${device.deviceName}:`, error);
                     }