tsvesync 1.0.11 → 1.0.12

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { VeSync } from './lib/vesync';
+export { VeSyncAirBypass } from './lib/vesyncFanImpl';
+export { VeSyncOutlet7A, VeSyncOutlet10A, VeSyncOutlet15A, VeSyncOutdoorPlug } from './lib/vesyncOutletImpl';
+export { VeSyncBulb } from './lib/vesyncBulb';
+export { VeSyncWallSwitch } from './lib/vesyncSwitchImpl';
+export { VeSyncBaseDevice } from './lib/vesyncBaseDevice';
+export { Helpers, setApiBaseUrl } from './lib/helpers';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setApiBaseUrl = exports.Helpers = exports.VeSyncBaseDevice = exports.VeSyncWallSwitch = exports.VeSyncBulb = exports.VeSyncOutdoorPlug = exports.VeSyncOutlet15A = exports.VeSyncOutlet10A = exports.VeSyncOutlet7A = exports.VeSyncAirBypass = exports.VeSync = void 0;
+// Export main VeSync manager class
+var vesync_1 = require("./lib/vesync");
+Object.defineProperty(exports, "VeSync", { enumerable: true, get: function () { return vesync_1.VeSync; } });
+// Export device classes
+var vesyncFanImpl_1 = require("./lib/vesyncFanImpl");
+Object.defineProperty(exports, "VeSyncAirBypass", { enumerable: true, get: function () { return vesyncFanImpl_1.VeSyncAirBypass; } });
+var vesyncOutletImpl_1 = require("./lib/vesyncOutletImpl");
+Object.defineProperty(exports, "VeSyncOutlet7A", { enumerable: true, get: function () { return vesyncOutletImpl_1.VeSyncOutlet7A; } });
+Object.defineProperty(exports, "VeSyncOutlet10A", { enumerable: true, get: function () { return vesyncOutletImpl_1.VeSyncOutlet10A; } });
+Object.defineProperty(exports, "VeSyncOutlet15A", { enumerable: true, get: function () { return vesyncOutletImpl_1.VeSyncOutlet15A; } });
+Object.defineProperty(exports, "VeSyncOutdoorPlug", { enumerable: true, get: function () { return vesyncOutletImpl_1.VeSyncOutdoorPlug; } });
+var vesyncBulb_1 = require("./lib/vesyncBulb");
+Object.defineProperty(exports, "VeSyncBulb", { enumerable: true, get: function () { return vesyncBulb_1.VeSyncBulb; } });
+var vesyncSwitchImpl_1 = require("./lib/vesyncSwitchImpl");
+Object.defineProperty(exports, "VeSyncWallSwitch", { enumerable: true, get: function () { return vesyncSwitchImpl_1.VeSyncWallSwitch; } });
+// Export base device class
+var vesyncBaseDevice_1 = require("./lib/vesyncBaseDevice");
+Object.defineProperty(exports, "VeSyncBaseDevice", { enumerable: true, get: function () { return vesyncBaseDevice_1.VeSyncBaseDevice; } });
+// Export helper functions
+var helpers_1 = require("./lib/helpers");
+Object.defineProperty(exports, "Helpers", { enumerable: true, get: function () { return helpers_1.Helpers; } });
+Object.defineProperty(exports, "setApiBaseUrl", { enumerable: true, get: function () { return helpers_1.setApiBaseUrl; } });

package/dist/lib/helpers.d.ts

@@ -1,87 +1,88 @@
+/**
+ * Helper functions for VeSync API
+ */
 import { VeSync } from './vesync';
-export declare const API_BASE_URL = "https://smartapi.vesync.com";
+export declare function getApiBaseUrl(): string;
+export declare function setApiBaseUrl(url: string): void;
 export declare const API_RATE_LIMIT = 30;
-export declare const API_TIMEOUT = 8;
-export declare const USER_AGENT = "VeSync/3.2.39 (com.etekcity.vesyncPlatform; build:5; iOS 15.5.0) Alamofire/5.2.1";
-export declare const DEFAULT_TZ = "America/New_York";
-export declare const DEFAULT_REGION = "US";
+export declare const API_TIMEOUT = 5000;
 export declare const APP_VERSION = "2.8.6";
 export declare const PHONE_BRAND = "SM N9005";
 export declare const PHONE_OS = "Android";
-export declare const MOBILE_ID = "1234567890123456";
 export declare const USER_TYPE = "1";
-export declare const BYPASS_APP_V = "VeSync 3.0.51";
+export declare const DEFAULT_TZ = "America/New_York";
+export declare const DEFAULT_REGION = "US";
+export declare const MOBILE_ID = "1234567890123456";
 export declare const BYPASS_HEADER_UA = "okhttp/3.12.1";
-export type Numeric = number | string | null;
-export type RequestBody = {
+export interface RequestBody {
+    acceptLanguage?: string;
+    accountID?: string;
+    appVersion?: string;
+    cid?: string;
+    configModule?: string;
+    debugMode?: boolean;
+    deviceRegion?: string;
+    email?: string;
+    method?: string;
+    password?: string;
+    phoneBrand?: string;
+    phoneOS?: string;
+    timeZone?: string;
+    token?: string;
+    traceId?: string;
+    userType?: string;
+    uuid?: string;
+    status?: string;
     [key: string]: any;
-};
+}
 export declare class Helpers {
-    private static shouldRedact;
+    static shouldRedact: boolean;
+    /**
+     * Calculate MD5 hash
+     */
+    static md5(text: string): string;
     /**
      * Build header for legacy api GET requests
      */
-    static reqHeaders(manager: VeSync): {
-        [key: string]: string;
-    };
+    static reqHeaders(manager: VeSync): Record<string, string>;
     /**
      * Build header for api requests on 'bypass' endpoint
      */
-    static reqHeaderBypass(): {
-        [key: string]: string;
-    };
+    static reqHeaderBypass(): Record<string, string>;
     /**
      * Return universal keys for body of api requests
      */
-    static reqBodyBase(manager: VeSync): {
-        [key: string]: string;
-    };
+    static reqBodyBase(manager: VeSync): Record<string, string>;
     /**
      * Keys for authenticating api requests
      */
-    static reqBodyAuth(manager: VeSync): RequestBody;
+    static reqBodyAuth(manager: VeSync): Record<string, any>;
     /**
      * Detail keys for api requests
      */
-    static reqBodyDetails(): RequestBody;
+    static reqBodyDetails(): Record<string, string>;
     /**
      * Builder for body of api requests
      */
-    static reqBody(manager: VeSync, type: string): RequestBody;
+    static reqBody(manager: VeSync, type: string): Record<string, any>;
     /**
-     * Calculate hex value
+     * Call VeSync API
      */
-    static calculateHex(hexString: string): number;
+    static callApi(endpoint: string, method: string, data?: any, headers?: Record<string, string>): Promise<[any, number]>;
     /**
-     * Hash password using MD5
+     * Calculate hex value from energy response
      */
-    static hashPassword(password: string): string;
+    static calculateHex(hexStr: string): string;
     /**
-     * Call the VeSync API
+     * Build energy dictionary from API response
      */
-    static callApi(api: string, method: string, jsonObject?: RequestBody, headers?: {
-        [key: string]: string;
-    }): Promise<[any, number]>;
+    static buildEnergyDict(result: any): Record<string, any>;
     /**
-     * Redact sensitive information
+     * Build configuration dictionary from API response
      */
-    static redactor(value: string): string;
-    static get redact(): boolean;
-    static set redact(value: boolean);
-}
-/**
- * Timer class for device scheduling
- */
-export declare class Timer {
-    status: string;
-    type: string;
-    id: string;
-    time: string;
-    action: string;
-    week: string;
-    state: string;
-    enabled: boolean;
-    private timer;
-    constructor(status?: string, type?: string, id?: string, time?: string, action?: string, week?: string, state?: string, enabled?: boolean);
-    toJson(): string;
+    static buildConfigDict(result: any): Record<string, any>;
+    /**
+     * Calculate MD5 hash
+     */
+    static hashPassword(text: string): string;
 }

package/dist/lib/helpers.js

@@ -1,39 +1,55 @@
 "use strict";
+/**
+ * Helper functions for VeSync API
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Timer = exports.Helpers = exports.BYPASS_HEADER_UA = exports.BYPASS_APP_V = exports.USER_TYPE = exports.MOBILE_ID = exports.PHONE_OS = exports.PHONE_BRAND = exports.APP_VERSION = exports.DEFAULT_REGION = exports.DEFAULT_TZ = exports.USER_AGENT = exports.API_TIMEOUT = exports.API_RATE_LIMIT = exports.API_BASE_URL = void 0;
-/**
- * Helper functions for VeSync API.
- */
+exports.Helpers = exports.BYPASS_HEADER_UA = exports.MOBILE_ID = exports.DEFAULT_REGION = exports.DEFAULT_TZ = exports.USER_TYPE = exports.PHONE_OS = exports.PHONE_BRAND = exports.APP_VERSION = exports.API_TIMEOUT = exports.API_RATE_LIMIT = void 0;
+exports.getApiBaseUrl = getApiBaseUrl;
+exports.setApiBaseUrl = setApiBaseUrl;
 const axios_1 = __importDefault(require("axios"));
 const crypto_1 = __importDefault(require("crypto"));
-exports.API_BASE_URL = 'https://smartapi.vesync.com';
+// API configuration
+let _apiBaseUrl = 'https://smartapi.vesync.com';
+function getApiBaseUrl() {
+    return _apiBaseUrl;
+}
+function setApiBaseUrl(url) {
+    _apiBaseUrl = url;
+}
 exports.API_RATE_LIMIT = 30;
-exports.API_TIMEOUT = 8;
-exports.USER_AGENT = "VeSync/3.2.39 (com.etekcity.vesyncPlatform; build:5; iOS 15.5.0) Alamofire/5.2.1";
-exports.DEFAULT_TZ = 'America/New_York';
-exports.DEFAULT_REGION = 'US';
+exports.API_TIMEOUT = 5000;
 exports.APP_VERSION = '2.8.6';
 exports.PHONE_BRAND = 'SM N9005';
 exports.PHONE_OS = 'Android';
-exports.MOBILE_ID = '1234567890123456';
 exports.USER_TYPE = '1';
-exports.BYPASS_APP_V = "VeSync 3.0.51";
+exports.DEFAULT_TZ = 'America/New_York';
+exports.DEFAULT_REGION = 'US';
+exports.MOBILE_ID = '1234567890123456';
 exports.BYPASS_HEADER_UA = 'okhttp/3.12.1';
 class Helpers {
+    /**
+     * Calculate MD5 hash
+     */
+    static md5(text) {
+        return crypto_1.default.createHash('md5').update(text).digest('hex');
+    }
     /**
      * Build header for legacy api GET requests
      */
     static reqHeaders(manager) {
+        if (!manager.accountId || !manager.token) {
+            throw new Error('Manager accountId and token must be set');
+        }
         return {
             'accept-language': 'en',
             'accountId': manager.accountId,
             'appVersion': exports.APP_VERSION,
             'content-type': 'application/json',
             'tk': manager.token,
-            'tz': manager.timeZone,
+            'tz': manager.timeZone
         };
     }
     /**
@@ -42,7 +58,7 @@ class Helpers {
     static reqHeaderBypass() {
         return {
             'Content-Type': 'application/json; charset=UTF-8',
-            'User-Agent': exports.BYPASS_HEADER_UA,
+            'User-Agent': exports.BYPASS_HEADER_UA
         };
     }
     /**
@@ -58,6 +74,9 @@ class Helpers {
      * Keys for authenticating api requests
      */
     static reqBodyAuth(manager) {
+        if (!manager.accountId || !manager.token) {
+            throw new Error('Manager accountId and token must be set');
+        }
         return {
             'accountID': manager.accountId,
             'token': manager.token
@@ -71,16 +90,18 @@ class Helpers {
             'appVersion': exports.APP_VERSION,
             'phoneBrand': exports.PHONE_BRAND,
             'phoneOS': exports.PHONE_OS,
-            'traceId': Math.floor(Date.now() / 1000).toString()
+            'traceId': Date.now().toString()
         };
     }
     /**
      * Builder for body of api requests
      */
     static reqBody(manager, type) {
-        let body = this.reqBodyBase(manager);
+        const body = {
+            ...this.reqBodyBase(manager)
+        };
         if (type === 'login') {
-            body = {
+            return {
                 ...body,
                 ...this.reqBodyDetails(),
                 email: manager.username,
@@ -89,72 +110,64 @@ class Helpers {
                 userType: exports.USER_TYPE,
                 method: 'login'
             };
-            return body;
         }
-        body = { ...body, ...this.reqBodyAuth(manager) };
+        const authBody = {
+            ...body,
+            ...this.reqBodyAuth(manager)
+        };
         if (type === 'devicestatus') {
-            return body;
+            return authBody;
         }
-        body = { ...body, ...this.reqBodyDetails() };
+        const fullBody = {
+            ...authBody,
+            ...this.reqBodyDetails()
+        };
         switch (type) {
             case 'devicelist':
-                body.method = 'devices';
-                body.pageNo = '1';
-                body.pageSize = '100';
-                break;
+                return {
+                    ...fullBody,
+                    method: 'devices',
+                    pageNo: '1',
+                    pageSize: '100'
+                };
             case 'devicedetail':
-                body.method = 'devicedetail';
-                body.mobileId = exports.MOBILE_ID;
-                break;
-            case 'energy_week':
-                body.method = 'energyweek';
-                body.mobileId = exports.MOBILE_ID;
-                break;
-            case 'energy_month':
-                body.method = 'energymonth';
-                body.mobileId = exports.MOBILE_ID;
-                break;
-            case 'energy_year':
-                body.method = 'energyyear';
-                body.mobileId = exports.MOBILE_ID;
-                break;
+                return {
+                    ...fullBody,
+                    method: 'devicedetail',
+                    mobileId: exports.MOBILE_ID
+                };
             case 'bypass':
-                body.method = 'bypass';
-                break;
+                return {
+                    ...fullBody,
+                    method: 'bypass'
+                };
             case 'bypassV2':
-                body.deviceRegion = exports.DEFAULT_REGION;
-                body.method = 'bypassV2';
-                break;
+                return {
+                    ...fullBody,
+                    deviceRegion: exports.DEFAULT_REGION,
+                    method: 'bypassV2'
+                };
             case 'bypass_config':
-                body.method = 'firmwareUpdateInfo';
-                break;
+                return {
+                    ...fullBody,
+                    method: 'firmwareUpdateInfo'
+                };
+            default:
+                return fullBody;
         }
-        return body;
-    }
-    /**
-     * Calculate hex value
-     */
-    static calculateHex(hexString) {
-        const hexConv = hexString.split(':');
-        return (parseInt(hexConv[0], 16) + parseInt(hexConv[1], 16)) / 8192;
     }
     /**
-     * Hash password using MD5
+     * Call VeSync API
      */
-    static hashPassword(password) {
-        return crypto_1.default.createHash('md5').update(password).digest('hex');
-    }
-    /**
-     * Call the VeSync API
-     */
-    static async callApi(api, method, jsonObject, headers) {
+    static async callApi(endpoint, method, data = null, headers = {}) {
         try {
+            const url = _apiBaseUrl + endpoint;
             const response = await (0, axios_1.default)({
-                method: method,
-                url: `${exports.API_BASE_URL}${api}`,
-                headers: headers,
-                data: jsonObject,
-                timeout: exports.API_TIMEOUT * 1000
+                method,
+                url,
+                data,
+                headers,
+                timeout: exports.API_TIMEOUT
             });
             return [response.data, response.status];
         }
@@ -162,61 +175,70 @@ class Helpers {
             if (error.response) {
                 return [error.response.data, error.response.status];
             }
-            throw error;
+            console.error('API call failed:', error.message);
+            return [null, 0];
         }
     }
     /**
-     * Redact sensitive information
+     * Calculate hex value from energy response
      */
-    static redactor(value) {
-        if (!this.shouldRedact) {
-            return value;
+    static calculateHex(hexStr) {
+        if (!hexStr || !hexStr.includes(':')) {
+            return '0';
+        }
+        const [prefix, value] = hexStr.split(':');
+        if (!prefix || !value) {
+            return '0';
         }
-        if (value.includes('@')) {
-            const parts = value.split('@');
-            return `${parts[0].charAt(0)}...@${parts[1]}`;
+        try {
+            const decoded = Buffer.from(value, 'hex');
+            return decoded.readFloatBE(0).toString();
         }
-        if (value.length > 3) {
-            return `${value.charAt(0)}...${value.charAt(value.length - 1)}`;
+        catch (error) {
+            console.debug('Error decoding hex value:', error);
+            return '0';
         }
-        return value;
     }
-    static get redact() {
-        return this.shouldRedact;
+    /**
+     * Build energy dictionary from API response
+     */
+    static buildEnergyDict(result) {
+        if (!result) {
+            return {};
+        }
+        return {
+            energy_consumption_of_today: result.energyConsumptionOfToday || 0,
+            cost_per_kwh: result.costPerKWH || 0,
+            max_energy: result.maxEnergy || 0,
+            total_energy: result.totalEnergy || 0,
+            data: result.data || [],
+            energy_consumption: result.energy || 0,
+            start_time: result.startTime || '',
+            end_time: result.endTime || ''
+        };
     }
-    static set redact(value) {
-        this.shouldRedact = value;
+    /**
+     * Build configuration dictionary from API response
+     */
+    static buildConfigDict(result) {
+        if (!result) {
+            return {};
+        }
+        return {
+            configModule: result.configModule || '',
+            firmwareVersion: result.currentFirmVersion || '',
+            deviceRegion: result.deviceRegion || '',
+            debugMode: result.debugMode || false,
+            deviceTimezone: result.deviceTimezone || exports.DEFAULT_TZ,
+            ...result
+        };
+    }
+    /**
+     * Calculate MD5 hash
+     */
+    static hashPassword(text) {
+        return crypto_1.default.createHash('md5').update(text).digest('hex');
     }
 }
 exports.Helpers = Helpers;
 Helpers.shouldRedact = true;
-/**
- * Timer class for device scheduling
- */
-class Timer {
-    constructor(status = '', type = '', id = '', time = '', action = '', week = '', state = '', enabled = false) {
-        this.status = status;
-        this.type = type;
-        this.id = id;
-        this.time = time;
-        this.action = action;
-        this.week = week;
-        this.state = state;
-        this.enabled = enabled;
-        this.timer = null;
-    }
-    toJson() {
-        return JSON.stringify({
-            status: this.status,
-            type: this.type,
-            id: this.id,
-            time: this.time,
-            action: this.action,
-            week: this.week,
-            state: this.state,
-            enabled: this.enabled
-        });
-    }
-}
-exports.Timer = Timer;
-//# sourceMappingURL=helpers.js.map

package/dist/lib/vesync.d.ts

@@ -1,47 +1,89 @@
-import { VeSyncBaseDevice, DeviceDetails } from './vesyncBaseDevice';
+/**
+ * VeSync API Device Library
+ */
+import { VeSyncBaseDevice } from './vesyncBaseDevice';
+/**
+ * VeSync Manager Class
+ */
 export declare class VeSync {
-    [x: number]: [any, number];
     private _debug;
     private _redact;
     private _energyUpdateInterval;
     private _energyCheck;
     private _devList;
+    private _lastUpdateTs;
+    private _inProcess;
     username: string;
     password: string;
     token: string | null;
     accountId: string | null;
     countryCode: string | null;
-    devices: any | null;
+    devices: VeSyncBaseDevice[] | null;
     enabled: boolean;
     updateInterval: number;
-    lastUpdateTs: number | null;
-    inProcess: boolean;
     timeZone: string;
     fans: VeSyncBaseDevice[];
     outlets: VeSyncBaseDevice[];
     switches: VeSyncBaseDevice[];
     bulbs: VeSyncBaseDevice[];
     scales: VeSyncBaseDevice[];
-    kitchen: VeSyncBaseDevice[];
+    /**
+     * Initialize VeSync Manager
+     */
     constructor(username: string, password: string, timeZone?: string, debug?: boolean, redact?: boolean);
+    /**
+     * Get/Set debug mode
+     */
     get debug(): boolean;
-    set debug(newFlag: boolean);
+    set debug(flag: boolean);
+    /**
+     * Get/Set redact mode
+     */
     get redact(): boolean;
-    set redact(newFlag: boolean);
+    set redact(flag: boolean);
+    /**
+     * Get/Set energy update interval
+     */
     get energyUpdateInterval(): number;
-    set energyUpdateInterval(newEnergyUpdate: number);
+    set energyUpdateInterval(interval: number);
     /**
-     * Test if device should be removed - false = Remove
+     * Test if device should be removed
      */
-    static removeDevTest(device: VeSyncBaseDevice, newList: DeviceDetails[]): boolean;
+    static removeDevTest(device: VeSyncBaseDevice, newList: any[]): boolean;
     /**
-     * Login to VeSync server
+     * Test if new device should be added
      */
-    login(): Promise<boolean>;
+    addDevTest(newDev: Record<string, any>): boolean;
+    /**
+     * Remove devices not found in device list return
+     */
+    removeOldDevices(devices: any[]): boolean;
+    /**
+     * Correct devices without cid or uuid
+     */
+    static setDevId(devices: any[]): any[];
+    /**
+     * Process device list and instantiate device objects
+     */
+    processDevices(devList: any[]): boolean;
     /**
      * Get list of VeSync devices
      */
     getDevices(): Promise<boolean>;
-    const body: import("./helpers").RequestBody;
-    if(: any, response: any): any;
+    /**
+     * Login to VeSync server
+     */
+    login(): Promise<boolean>;
+    /**
+     * Test if update interval has been exceeded
+     */
+    deviceTimeCheck(): boolean;
+    /**
+     * Update device list and details
+     */
+    update(): Promise<void>;
+    /**
+     * Create device instance from details
+     */
+    createDevice(details: Record<string, any>): VeSyncBaseDevice | null;
 }