tsvesync 1.0.13 → 1.0.14

package/dist/src/lib/vesync.js

@@ -1,430 +0,0 @@
-"use strict";
-/**
- * VeSync API Device Library
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VeSync = void 0;
-const helpers_1 = require("./helpers");
-const vesyncFanImpl_1 = require("./vesyncFanImpl");
-const vesyncOutletImpl_1 = require("./vesyncOutletImpl");
-const vesyncSwitchImpl_1 = require("./vesyncSwitchImpl");
-const vesyncBulbImpl_1 = require("./vesyncBulbImpl");
-const DEFAULT_ENERGY_UPDATE_INTERVAL = 21600;
-/**
- * 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
-    };
-    // First try exact match in all modules
-    for (const [cat, modules] of Object.entries(allModules)) {
-        if (deviceType in modules) {
-            DeviceClass = modules[deviceType];
-            category = cat;
-            console.debug(`Found exact match for ${deviceType} in ${cat} modules`);
-            break;
-        }
-    }
-    // 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;
-                console.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;
-                        console.debug(`Found base type match: ${deviceType} -> ${baseType}`);
-                        break;
-                    }
-                }
-                break;
-            }
-        }
-    }
-    if (DeviceClass) {
-        try {
-            // Add category to device details
-            details.deviceCategory = category;
-            const device = new DeviceClass(details, manager);
-            return [category, device];
-        }
-        catch (error) {
-            console.error(`Error creating device instance for ${deviceType}:`, error);
-            return [category, null];
-        }
-    }
-    else {
-        console.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._debug = debug;
-        this._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;
-        this.accountId = null;
-        this.countryCode = null;
-        this.devices = null;
-        this.enabled = false;
-        this.updateInterval = helpers_1.API_RATE_LIMIT;
-        this.fans = [];
-        this.outlets = [];
-        this.switches = [];
-        this.bulbs = [];
-        this.scales = [];
-        this._devList = {
-            fans: this.fans,
-            outlets: this.outlets,
-            switches: this.switches,
-            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 - ', timeZone);
-            }
-            else {
-                this.timeZone = timeZone;
-            }
-        }
-        else {
-            this.timeZone = helpers_1.DEFAULT_TZ;
-            console.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(flag) {
-        this._debug = flag;
-    }
-    /**
-     * Get/Set redact mode
-     */
-    get redact() {
-        return this._redact;
-    }
-    set redact(flag) {
-        this._redact = flag;
-        helpers_1.Helpers.shouldRedact = flag;
-    }
-    /**
-     * Get/Set energy update interval
-     */
-    get energyUpdateInterval() {
-        return this._energyUpdateInterval;
-    }
-    set energyUpdateInterval(interval) {
-        if (interval > 0) {
-            this._energyUpdateInterval = interval;
-        }
-    }
-    /**
-     * Test if device should be removed
-     */
-    static removeDevTest(device, newList) {
-        if (Array.isArray(newList) && device.cid) {
-            for (const item of newList) {
-                if ('cid' in item && device.cid === item.cid) {
-                    return true;
-                }
-            }
-            console.debug(`Device removed - ${device.deviceName} - ${device.deviceType}`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Test if new device should be added
-     */
-    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;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Remove devices not found in device list return
-     */
-    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) {
-                console.debug(`${before - after} ${key} removed`);
-            }
-        }
-        return true;
-    }
-    /**
-     * 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);
-                    console.warn(`Device with no ID - ${dev.deviceName || ''}`);
-                }
-            }
-        });
-        if (devRem.length > 0) {
-            return devices.filter((_, index) => !devRem.includes(index));
-        }
-        return devices;
-    }
-    /**
-     * 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) {
-            console.warn('No devices found in api return');
-            return false;
-        }
-        // Initialize new device list or remove old devices
-        if (numDevices === 0) {
-            console.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)) {
-                console.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);
-                    console.debug(`Added ${devType} device to ${category} category`);
-                }
-                else if (category === 'unknown') {
-                    console.debug(`Unknown device type: ${devType}`);
-                }
-            }
-            catch (err) {
-                console.error(`Error creating device ${devType}:`, err);
-                continue;
-            }
-        }
-        return true;
-    }
-    /**
-     * Get list of VeSync devices
-     */
-    async getDevices() {
-        if (!this.enabled) {
-            console.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 (response?.result?.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
-                console.log('\n=== Device Discovery Summary ===');
-                console.log(`Total devices processed: ${deviceList.length}`);
-                // Log device types found
-                const deviceTypes = deviceList.map((d) => d.deviceType);
-                console.log('\nDevice types found:', deviceTypes);
-                // Log devices by category with details
-                console.log('\nDevices by Category:');
-                console.log('---------------------');
-                for (const [category, devices] of Object.entries(this._devList)) {
-                    if (devices.length > 0) {
-                        console.log(`\n${category.toUpperCase()} (${devices.length} devices):`);
-                        devices.forEach((d) => {
-                            console.log(`  • ${d.deviceName}`);
-                            console.log(`    Type: ${d.deviceType}`);
-                            console.log(`    Status: ${d.deviceStatus}`);
-                            console.log(`    ID: ${d.cid}`);
-                        });
-                    }
-                }
-                // Log summary statistics
-                console.log('\nSummary Statistics:');
-                console.log('-------------------');
-                console.log(`Total Devices: ${this.devices?.length || 0}`);
-                for (const [category, devices] of Object.entries(this._devList)) {
-                    console.log(`${category}: ${devices.length} devices`);
-                }
-                console.log('\n=== End of Device Discovery ===\n');
-            }
-            else {
-                console.error('No devices found in response');
-            }
-        }
-        catch (error) {
-            console.error('Unable to get device list:', error);
-        }
-        this._inProcess = false;
-        return procReturn;
-    }
-    /**
-     * Login to VeSync server
-     */
-    async login() {
-        const body = helpers_1.Helpers.reqBody(this, 'login');
-        console.log('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);
-            console.log('Login response:', { status, response });
-            if (response?.result?.token) {
-                this.token = response.result.token;
-                this.accountId = response.result.accountID;
-                this.countryCode = response.result.countryCode;
-                this.enabled = true;
-                return true;
-            }
-            console.error('Unable to login with supplied credentials');
-            return false;
-        }
-        catch (error) {
-            console.error('Login error:', error);
-            return false;
-        }
-    }
-    /**
-     * 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) {
-                console.error('Not logged in to VeSync');
-                return;
-            }
-            await this.getDevices();
-            console.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) {
-                        console.error(`Error updating ${device.deviceName}:`, error);
-                    }
-                }
-            }
-            this._lastUpdateTs = Date.now();
-        }
-    }
-    /**
-     * 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;
-    }
-}
-exports.VeSync = VeSync;

package/dist/src/lib/vesyncBaseDevice.d.ts

@@ -1,43 +0,0 @@
-/**
- * Base class for VeSync devices
- */
-import { VeSync } from './vesync';
-export declare abstract class VeSyncBaseDevice {
-    protected manager: VeSync;
-    protected config: Record<string, any>;
-    cid: string;
-    deviceName: string;
-    deviceStatus: string;
-    deviceType: string;
-    deviceRegion: string;
-    uuid: string;
-    configModule: string;
-    macId: string;
-    deviceCategory: string;
-    connectionStatus: string;
-    constructor(details: Record<string, any>, manager: VeSync);
-    /**
-     * Return formatted device info to stdout
-     */
-    display(): void;
-    /**
-     * Return JSON details for device
-     */
-    displayJSON(): string;
-    /**
-     * Check API response for errors
-     */
-    protected checkResponse(response: [any, number], method: string): boolean;
-    /**
-     * Log error with context
-     */
-    protected logError(method: string, error: any): void;
-    /**
-     * Get device details
-     */
-    abstract getDetails(): Promise<void>;
-    /**
-     * Update device details
-     */
-    update(): Promise<void>;
-}

package/dist/src/lib/vesyncBaseDevice.js

@@ -1,87 +0,0 @@
-"use strict";
-/**
- * Base class for VeSync devices
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VeSyncBaseDevice = void 0;
-class VeSyncBaseDevice {
-    constructor(details, manager) {
-        this.config = {};
-        this.manager = manager;
-        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 formatted device info to stdout
-     */
-    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 JSON details for device
-     */
-    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);
-    }
-    /**
-     * Check API response for errors
-     */
-    checkResponse(response, method) {
-        const [data, status] = response;
-        // Check HTTP status
-        if (status !== 200) {
-            this.logError(method, `Invalid HTTP status: ${status}`);
-            return false;
-        }
-        // 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;
-    }
-    /**
-     * Log error with context
-     */
-    logError(method, error) {
-        const errorMsg = error?.message || error;
-        console.error(`[${this.deviceName}] ${method}: ${errorMsg}`);
-        // Log additional error details if available
-        if (error?.response?.data) {
-            const responseData = error.response.data;
-            const msg = responseData.msg || responseData.message || JSON.stringify(responseData);
-            console.error(`Response: ${msg}`);
-        }
-    }
-    /**
-     * Update device details
-     */
-    async update() {
-        await this.getDetails();
-    }
-}
-exports.VeSyncBaseDevice = VeSyncBaseDevice;

package/dist/src/lib/vesyncBulb.d.ts

@@ -1,79 +0,0 @@
-/**
- * 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>;
-}