tsvesync 1.0.11 → 1.0.12

package/dist/lib/vesyncBaseDevice.d.ts

@@ -1,68 +1,43 @@
 /**
- * Base class for all VeSync devices
+ * Base class for VeSync devices
  */
 import { VeSync } from './vesync';
-export interface DeviceDetails {
-    deviceName: string;
-    deviceImg?: string;
-    cid: string;
-    connectionStatus: string;
-    connectionType?: string;
-    deviceType: string;
-    type?: string;
-    uuid?: string;
-    configModule: string;
-    macID?: string;
-    mode?: string;
-    speed?: number | string;
-    extension?: any;
-    currentFirmVersion?: string;
-    deviceRegion?: string;
-    deviceStatus?: string;
-    subDeviceNo?: number;
-}
-export declare class VeSyncBaseDevice {
+export declare abstract class VeSyncBaseDevice {
     protected manager: VeSync;
-    deviceName: string;
-    deviceImage: string | null;
+    protected config: Record<string, any>;
     cid: string;
-    connectionStatus: string;
-    connectionType: string | null;
+    deviceName: string;
+    deviceStatus: string;
     deviceType: string;
-    type: string | null;
-    uuid: string | null;
+    deviceRegion: string;
+    uuid: string;
     configModule: string;
-    macId: string | null;
-    mode: string | null;
-    speed: number | null;
-    extension: any;
-    currentFirmVersion: string | null;
-    deviceRegion: string | null;
-    pid: string | null;
-    subDeviceNo: number;
-    config: {
-        [key: string]: any;
-    };
-    deviceStatus: string | null;
-    constructor(details: DeviceDetails, manager: VeSync);
+    macId: string;
+    deviceCategory: string;
+    connectionStatus: string;
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Return formatted device info to stdout
+     */
+    display(): void;
     /**
-     * Return true if device is on
+     * Return JSON details for device
      */
-    get isOn(): boolean;
+    displayJSON(): string;
     /**
-     * Return true if firmware update available
+     * Check API response for errors
      */
-    get firmwareUpdate(): boolean;
+    protected checkResponse(response: [any, number], method: string): boolean;
     /**
-     * Get managed device configuration
+     * Log error with context
      */
-    getPid(): Promise<void>;
+    protected logError(method: string, error: any): void;
     /**
-     * Display device details
+     * Get device details
      */
-    display(): void;
+    abstract getDetails(): Promise<void>;
     /**
-     * Return device details as JSON string
+     * Update device details
      */
-    displayJSON(): string;
+    update(): Promise<void>;
 }

package/dist/lib/vesyncBaseDevice.js

@@ -1,116 +1,88 @@
 "use strict";
+/**
+ * Base class for VeSync devices
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VeSyncBaseDevice = void 0;
-const helpers_1 = require("./helpers");
 class VeSyncBaseDevice {
     constructor(details, manager) {
+        this.config = {};
         this.manager = manager;
-        if (details.cid) {
-            this.deviceName = details.deviceName;
-            this.deviceImage = details.deviceImg || null;
-            this.cid = details.cid;
-            this.connectionStatus = details.connectionStatus;
-            this.connectionType = details.connectionType || null;
-            this.deviceType = details.deviceType;
-            this.type = details.type || null;
-            this.uuid = details.uuid || null;
-            this.configModule = details.configModule;
-            this.macId = details.macID || null;
-            this.mode = details.mode || null;
-            this.speed = typeof details.speed === 'string' && details.speed !== ''
-                ? parseInt(details.speed)
-                : (typeof details.speed === 'number' ? details.speed : null);
-            this.extension = details.extension;
-            this.currentFirmVersion = details.currentFirmVersion || null;
-            this.deviceRegion = details.deviceRegion || null;
-            this.pid = null;
-            this.subDeviceNo = details.subDeviceNo || 0;
-            this.config = {};
-            if (typeof details.extension === 'object' && details.extension !== null) {
-                const ext = details.extension;
-                this.speed = ext.fanSpeedLevel;
-                this.mode = ext.mode;
-            }
-            if (this.connectionStatus !== 'online') {
-                this.deviceStatus = 'off';
-            }
-            else {
-                this.deviceStatus = details.deviceStatus || null;
-            }
-        }
-        else {
-            throw new Error(`No cid found for ${this.constructor.name}`);
-        }
+        this.cid = details.cid || '';
+        this.deviceName = details.deviceName || '';
+        this.deviceStatus = details.deviceStatus || 'off';
+        this.deviceType = details.deviceType || '';
+        this.deviceRegion = details.deviceRegion || '';
+        this.uuid = details.uuid || '';
+        this.configModule = details.configModule || '';
+        this.macId = details.macId || '';
+        this.deviceCategory = details.deviceCategory || '';
+        this.connectionStatus = details.connectionStatus || 'offline';
     }
     /**
-     * Return true if device is on
+     * Return formatted device info to stdout
      */
-    get isOn() {
-        return this.deviceStatus === 'on';
+    display() {
+        console.log(`Device Name: ${this.deviceName}`);
+        console.log(`Status: ${this.deviceStatus}`);
+        console.log(`Device Type: ${this.deviceType}`);
+        console.log(`Connection: ${this.connectionStatus}`);
+        console.log(`Version: ${this.config.current_firmware_version || 'Unknown'}`);
     }
     /**
-     * Return true if firmware update available
+     * Return JSON details for device
      */
-    get firmwareUpdate() {
-        const cfv = this.config?.current_firmware_version;
-        const lfv = this.config?.latest_firmware_version;
-        if (cfv !== undefined && lfv !== undefined) {
-            return cfv !== lfv;
-        }
-        console.debug('Call device.getConfig() to get firmware versions');
-        return false;
+    displayJSON() {
+        return JSON.stringify({
+            'Device Name': this.deviceName,
+            'Status': this.deviceStatus,
+            'Device Type': this.deviceType,
+            'Connection': this.connectionStatus,
+            'Version': this.config.current_firmware_version || 'Unknown'
+        }, null, 4);
     }
     /**
-     * Get managed device configuration
+     * Check API response for errors
      */
-    async getPid() {
-        const body = helpers_1.Helpers.reqBody(this.manager, 'devicedetail');
-        body.configModule = this.configModule;
-        body.region = this.deviceRegion;
-        body.method = 'configInfo';
-        const [response] = await helpers_1.Helpers.callApi('/cloud/v1/deviceManaged/configInfo', 'post', body);
-        if (typeof response !== 'object' ||
-            response.code !== 0 ||
-            !response.result) {
-            console.error(`Error getting config info for ${this.deviceName}`);
-            return;
+    checkResponse(response, method) {
+        const [data, status] = response;
+        // Check HTTP status
+        if (status !== 200) {
+            this.logError(method, `Invalid HTTP status: ${status}`);
+            return false;
         }
-        this.pid = response.result?.pid;
+        // Check API response
+        if (!data) {
+            this.logError(method, 'No response data');
+            return false;
+        }
+        // Check error code - code 0 indicates success
+        if (data.code === 0) {
+            return true;
+        }
+        const msg = data.msg || 'Unknown error';
+        this.logError(method, `Error code ${data.code}: ${msg}`);
+        return false;
     }
     /**
-     * Display device details
+     * Log error with context
      */
-    display() {
-        const disp = [
-            ['Device Name:', this.deviceName],
-            ['Model:', this.deviceType],
-            ['Subdevice No:', this.subDeviceNo.toString()],
-            ['Status:', this.deviceStatus],
-            ['Online:', this.connectionStatus],
-            ['Type:', this.type],
-            ['CID:', this.cid],
-        ];
-        if (this.uuid) {
-            disp.push(['UUID:', this.uuid]);
-        }
-        for (const line of disp) {
-            console.log(`${line[0].padEnd(30, '.')} ${line[1]}`);
+    logError(method, error) {
+        var _a;
+        const errorMsg = (error === null || error === void 0 ? void 0 : error.message) || error;
+        console.error(`[${this.deviceName}] ${method}: ${errorMsg}`);
+        // Log additional error details if available
+        if ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) {
+            const responseData = error.response.data;
+            const msg = responseData.msg || responseData.message || JSON.stringify(responseData);
+            console.error(`Response: ${msg}`);
         }
     }
     /**
-     * Return device details as JSON string
+     * Update device details
      */
-    displayJSON() {
-        return JSON.stringify({
-            'Device Name': this.deviceName,
-            'Model': this.deviceType,
-            'Subdevice No': this.subDeviceNo.toString(),
-            'Status': this.deviceStatus,
-            'Online': this.connectionStatus,
-            'Type': this.type,
-            'CID': this.cid,
-        }, null, 4);
+    async update() {
+        await this.getDetails();
     }
 }
 exports.VeSyncBaseDevice = VeSyncBaseDevice;
-//# sourceMappingURL=vesyncBaseDevice.js.map

package/dist/lib/vesyncBulb.d.ts

@@ -0,0 +1,79 @@
+/**
+ * VeSync Bulb Base Class
+ */
+import { VeSyncBaseDevice } from './vesyncBaseDevice';
+import { VeSync } from './vesync';
+/**
+ * VeSync Bulb Base Class
+ */
+export declare abstract class VeSyncBulb extends VeSyncBaseDevice {
+    protected brightness: number;
+    protected colorTemp: number;
+    protected colorValue: number;
+    protected colorHue: number;
+    protected colorSaturation: number;
+    protected colorMode: string;
+    protected features: string[];
+    protected rgbValues: {
+        red: number;
+        green: number;
+        blue: number;
+    };
+    constructor(details: Record<string, any>, manager: VeSync);
+    /**
+     * Get bulb details
+     */
+    getDetails(): Promise<void>;
+    /**
+     * Update bulb status
+     */
+    update(): Promise<void>;
+    /**
+     * Turn bulb on
+     */
+    turnOn(): Promise<boolean>;
+    /**
+     * Turn bulb off
+     */
+    turnOff(): Promise<boolean>;
+    /**
+     * Set bulb brightness
+     */
+    setBrightness(brightness: number): Promise<boolean>;
+    /**
+     * Get bulb brightness
+     */
+    getBrightness(): number;
+    /**
+     * Get color temperature in Kelvin
+     */
+    getColorTempKelvin(): number;
+    /**
+     * Get color temperature in percent
+     */
+    getColorTempPercent(): number;
+    /**
+     * Get color hue
+     */
+    getColorHue(): number;
+    /**
+     * Get color saturation
+     */
+    getColorSaturation(): number;
+    /**
+     * Get color value
+     */
+    getColorValue(): number;
+    /**
+     * Get RGB values
+     */
+    getRGBValues(): {
+        red: number;
+        green: number;
+        blue: number;
+    };
+    /**
+     * Set color temperature - Abstract method to be implemented by subclasses
+     */
+    abstract setColorTemp(colorTemp: number): Promise<boolean>;
+}

package/dist/lib/vesyncBulb.js

@@ -1,2 +1,199 @@
 "use strict";
-//# sourceMappingURL=vesyncBulb.js.map
+/**
+ * VeSync Bulb Base Class
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncBulb = void 0;
+const vesyncBaseDevice_1 = require("./vesyncBaseDevice");
+const helpers_1 = require("./helpers");
+// Feature dictionary for bulb types
+const featureDict = {
+    'ESL100': {
+        features: ['dimmable'],
+        colorModel: 'none'
+    },
+    'ESL100CW': {
+        features: ['dimmable', 'color_temp'],
+        colorModel: 'none'
+    },
+    'XYD0001': {
+        features: ['dimmable', 'color_temp', 'rgb_shift'],
+        colorModel: 'hsv'
+    },
+    'ESL100MC': {
+        features: ['dimmable', 'rgb_shift'],
+        colorModel: 'rgb'
+    }
+};
+/**
+ * VeSync Bulb Base Class
+ */
+class VeSyncBulb extends vesyncBaseDevice_1.VeSyncBaseDevice {
+    constructor(details, manager) {
+        var _a;
+        super(details, manager);
+        this.brightness = 0;
+        this.colorTemp = 0;
+        this.colorValue = 0;
+        this.colorHue = 0;
+        this.colorSaturation = 0;
+        this.colorMode = '';
+        this.features = ((_a = featureDict[this.deviceType]) === null || _a === void 0 ? void 0 : _a.features) || [];
+        this.rgbValues = {
+            red: 0,
+            green: 0,
+            blue: 0
+        };
+    }
+    /**
+     * Get bulb details
+     */
+    async getDetails() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicedetail'),
+            uuid: this.cid,
+            method: 'devicedetail'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/devicedetail', 'post', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if ((response === null || response === void 0 ? void 0 : response.code) === 0 && (response === null || response === void 0 ? void 0 : response.result)) {
+            this.deviceStatus = response.result.deviceStatus || this.deviceStatus;
+            this.brightness = response.result.brightness || this.brightness;
+            if (this.features.includes('color_temp')) {
+                this.colorTemp = response.result.colorTemp || this.colorTemp;
+            }
+            if (this.features.includes('rgb_shift')) {
+                if (featureDict[this.deviceType].colorModel === 'rgb') {
+                    this.rgbValues = {
+                        red: response.result.red || this.rgbValues.red,
+                        green: response.result.green || this.rgbValues.green,
+                        blue: response.result.blue || this.rgbValues.blue
+                    };
+                }
+                else {
+                    this.colorHue = response.result.hue || this.colorHue;
+                    this.colorSaturation = response.result.saturation || this.colorSaturation;
+                    this.colorValue = response.result.value || this.colorValue;
+                }
+            }
+        }
+    }
+    /**
+     * Update bulb status
+     */
+    async update() {
+        await this.getDetails();
+    }
+    /**
+     * Turn bulb on
+     */
+    async turnOn() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if ((response === null || response === void 0 ? void 0 : response.code) === 0) {
+            this.deviceStatus = 'on';
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Turn bulb off
+     */
+    async turnOff() {
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'off'
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if ((response === null || response === void 0 ? void 0 : response.code) === 0) {
+            this.deviceStatus = 'off';
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Set bulb brightness
+     */
+    async setBrightness(brightness) {
+        if (!this.features.includes('dimmable')) {
+            return false;
+        }
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.cid,
+            status: 'on',
+            brightNess: brightness.toString()
+        };
+        const [response] = await helpers_1.Helpers.callApi('/SmartBulb/v1/device/updateBrightness', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
+        if ((response === null || response === void 0 ? void 0 : response.code) === 0) {
+            this.brightness = brightness;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get bulb brightness
+     */
+    getBrightness() {
+        return this.brightness;
+    }
+    /**
+     * Get color temperature in Kelvin
+     */
+    getColorTempKelvin() {
+        if (!this.features.includes('color_temp')) {
+            return 0;
+        }
+        return ((6500 - 2700) * this.colorTemp / 100) + 2700;
+    }
+    /**
+     * Get color temperature in percent
+     */
+    getColorTempPercent() {
+        if (!this.features.includes('color_temp')) {
+            return 0;
+        }
+        return this.colorTemp;
+    }
+    /**
+     * Get color hue
+     */
+    getColorHue() {
+        if (!this.features.includes('rgb_shift')) {
+            return 0;
+        }
+        return this.colorHue;
+    }
+    /**
+     * Get color saturation
+     */
+    getColorSaturation() {
+        if (!this.features.includes('rgb_shift')) {
+            return 0;
+        }
+        return this.colorSaturation;
+    }
+    /**
+     * Get color value
+     */
+    getColorValue() {
+        if (!this.features.includes('rgb_shift')) {
+            return 0;
+        }
+        return this.colorValue;
+    }
+    /**
+     * Get RGB values
+     */
+    getRGBValues() {
+        if (!this.features.includes('rgb_shift') || featureDict[this.deviceType].colorModel !== 'rgb') {
+            return { red: 0, green: 0, blue: 0 };
+        }
+        return this.rgbValues;
+    }
+}
+exports.VeSyncBulb = VeSyncBulb;

package/dist/lib/vesyncBulbImpl.d.ts

@@ -0,0 +1,38 @@
+/**
+ * VeSync Bulb Implementations
+ */
+import { VeSyncBulb } from './vesyncBulb';
+import { VeSync } from './vesync';
+/**
+ * ESL100 Bulb Implementation
+ */
+export declare class VeSyncBulbESL100 extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+}
+/**
+ * ESL100CW Bulb Implementation
+ */
+export declare class VeSyncBulbESL100CW extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+}
+/**
+ * XYD0001 Bulb Implementation
+ */
+export declare class VeSyncBulbXYD0001 extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+    setHsv(hue: number, saturation: number, value: number): Promise<boolean>;
+    enableWhiteMode(): Promise<boolean>;
+}
+/**
+ * ESL100MC Bulb Implementation
+ */
+export declare class VeSyncBulbESL100MC extends VeSyncBulb {
+    constructor(details: Record<string, any>, manager: VeSync);
+    setColorTemp(colorTemp: number): Promise<boolean>;
+    setRgb(red: number, green: number, blue: number): Promise<boolean>;
+    enableWhiteMode(): Promise<boolean>;
+}
+export declare const bulbModules: Record<string, any>;