homebridge-tuya-pool-heater 1.0.1

package/dist/heaterCoolerAccessory.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaterCoolerAccessory = void 0;
+const settings_1 = require("./settings");
+class HeaterCoolerAccessory {
+    service;
+    platform;
+    accessory;
+    deviceConfig;
+    // Cached state
+    active = false;
+    currentTemperature = 20;
+    heatingThresholdTemperature = 28;
+    coolingThresholdTemperature = 20;
+    currentHeaterCoolerState = 0; // INACTIVE
+    targetHeaterCoolerState = 0; // AUTO
+    // Debounce polling after commands
+    lastCommandTime = 0;
+    commandDebounceMs = 10000; // Ignore polls for 10 seconds after command
+    constructor(platform, accessory, deviceConfig) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.deviceConfig = deviceConfig;
+        // Set accessory information
+        this.accessory.getService(this.platform.Service.AccessoryInformation)
+            .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Tuya')
+            .setCharacteristic(this.platform.Characteristic.Model, 'Pool Heat Pump')
+            .setCharacteristic(this.platform.Characteristic.SerialNumber, deviceConfig.id);
+        // Get or create HeaterCooler service
+        this.service = this.accessory.getService(this.platform.Service.HeaterCooler)
+            || this.accessory.addService(this.platform.Service.HeaterCooler);
+        this.service.setCharacteristic(this.platform.Characteristic.Name, deviceConfig.name);
+        // Configure Active
+        this.service.getCharacteristic(this.platform.Characteristic.Active)
+            .onGet(this.getActive.bind(this))
+            .onSet(this.setActive.bind(this));
+        // Configure CurrentTemperature
+        this.service.getCharacteristic(this.platform.Characteristic.CurrentTemperature)
+            .setProps({
+            minValue: -10,
+            maxValue: 60,
+            minStep: 0.1,
+        })
+            .onGet(this.getCurrentTemperature.bind(this));
+        // Configure CurrentHeaterCoolerState (read-only)
+        this.service.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState)
+            .onGet(this.getCurrentHeaterCoolerState.bind(this));
+        // Configure TargetHeaterCoolerState
+        this.service.getCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState)
+            .onGet(this.getTargetHeaterCoolerState.bind(this))
+            .onSet(this.setTargetHeaterCoolerState.bind(this));
+        // Configure HeatingThresholdTemperature
+        this.service.getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
+            .setProps({
+            minValue: 5,
+            maxValue: 55,
+            minStep: 1,
+        })
+            .onGet(this.getHeatingThresholdTemperature.bind(this))
+            .onSet(this.setHeatingThresholdTemperature.bind(this));
+        // Configure CoolingThresholdTemperature
+        this.service.getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
+            .setProps({
+            minValue: 5,
+            maxValue: 35,
+            minStep: 1,
+        })
+            .onGet(this.getCoolingThresholdTemperature.bind(this))
+            .onSet(this.setCoolingThresholdTemperature.bind(this));
+        // Register for status updates
+        this.platform.registerStatusCallback(this.deviceConfig.id, (status) => {
+            this.updateState(status);
+        });
+        // Initial status fetch
+        this.fetchInitialStatus();
+    }
+    async fetchInitialStatus() {
+        try {
+            const status = await this.platform.tuyaApi.getDeviceStatus(this.deviceConfig.id);
+            this.updateState(status);
+        }
+        catch (error) {
+            this.platform.log.error('Failed to fetch initial status:', error);
+        }
+    }
+    updateState(status) {
+        // Ignore polled updates briefly after sending a command to avoid race conditions
+        if (Date.now() - this.lastCommandTime < this.commandDebounceMs) {
+            this.platform.log.debug('Ignoring polled state update (recent command sent)');
+            return;
+        }
+        for (const dp of status) {
+            switch (dp.code) {
+                case settings_1.DP_CODES.SWITCH:
+                    this.active = dp.value;
+                    this.service.updateCharacteristic(this.platform.Characteristic.Active, this.active
+                        ? this.platform.Characteristic.Active.ACTIVE
+                        : this.platform.Characteristic.Active.INACTIVE);
+                    if (!this.active) {
+                        this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+                        this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.currentHeaterCoolerState);
+                    }
+                    break;
+                case settings_1.DP_CODES.TEMP_CURRENT:
+                    this.currentTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                    this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.currentTemperature);
+                    break;
+                case settings_1.DP_CODES.SET_HEATING_TEMP:
+                    this.heatingThresholdTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                    this.service.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.heatingThresholdTemperature);
+                    break;
+                case settings_1.DP_CODES.SET_COOLING_TEMP:
+                    this.coolingThresholdTemperature = (0, settings_1.tuyaTempToCelsius)(dp.value);
+                    this.service.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.coolingThresholdTemperature);
+                    break;
+                case settings_1.DP_CODES.MODE:
+                    this.updateModeFromTuya(dp.value);
+                    break;
+            }
+        }
+    }
+    updateModeFromTuya(mode) {
+        if (!this.active) {
+            this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+        }
+        else if ((0, settings_1.isHeatingMode)(mode)) {
+            this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
+            this.targetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
+        }
+        else if ((0, settings_1.isCoolingMode)(mode)) {
+            this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
+            this.targetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.COOL;
+        }
+        else {
+            // Auto mode - determine current state based on current vs target temp
+            if (this.currentTemperature < this.heatingThresholdTemperature) {
+                this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
+            }
+            else if (this.currentTemperature > this.coolingThresholdTemperature) {
+                this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
+            }
+            else {
+                this.currentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
+            }
+            this.targetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
+        }
+        this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.currentHeaterCoolerState);
+        this.service.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.targetHeaterCoolerState);
+    }
+    // Handlers
+    async getActive() {
+        return this.active
+            ? this.platform.Characteristic.Active.ACTIVE
+            : this.platform.Characteristic.Active.INACTIVE;
+    }
+    async setActive(value) {
+        const active = value === this.platform.Characteristic.Active.ACTIVE;
+        this.platform.log.info(`Setting active to ${active}`);
+        this.lastCommandTime = Date.now();
+        const success = await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.SWITCH, active);
+        if (success) {
+            this.active = active;
+        }
+    }
+    async getCurrentTemperature() {
+        return this.currentTemperature;
+    }
+    async getCurrentHeaterCoolerState() {
+        return this.currentHeaterCoolerState;
+    }
+    async getTargetHeaterCoolerState() {
+        return this.targetHeaterCoolerState;
+    }
+    async setTargetHeaterCoolerState(value) {
+        const state = value;
+        this.platform.log.info(`Setting target heater/cooler state to ${state}`);
+        this.lastCommandTime = Date.now();
+        let mode;
+        switch (state) {
+            case this.platform.Characteristic.TargetHeaterCoolerState.HEAT:
+                mode = settings_1.TUYA_MODES.HEATING_SMART;
+                break;
+            case this.platform.Characteristic.TargetHeaterCoolerState.COOL:
+                mode = settings_1.TUYA_MODES.COOLING_SMART;
+                break;
+            case this.platform.Characteristic.TargetHeaterCoolerState.AUTO:
+            default:
+                mode = settings_1.TUYA_MODES.AUTO;
+                break;
+        }
+        const success = await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.MODE, mode);
+        if (success) {
+            this.targetHeaterCoolerState = state;
+        }
+    }
+    async getHeatingThresholdTemperature() {
+        return this.heatingThresholdTemperature;
+    }
+    async setHeatingThresholdTemperature(value) {
+        const temp = value;
+        this.platform.log.info(`Setting heating threshold temperature to ${temp}°C`);
+        this.lastCommandTime = Date.now();
+        const tuyaTemp = (0, settings_1.celsiusToTuyaTemp)(temp);
+        const success = await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.SET_HEATING_TEMP, tuyaTemp);
+        if (success) {
+            this.heatingThresholdTemperature = temp;
+        }
+    }
+    async getCoolingThresholdTemperature() {
+        return this.coolingThresholdTemperature;
+    }
+    async setCoolingThresholdTemperature(value) {
+        const temp = value;
+        this.platform.log.info(`Setting cooling threshold temperature to ${temp}°C`);
+        this.lastCommandTime = Date.now();
+        const tuyaTemp = (0, settings_1.celsiusToTuyaTemp)(temp);
+        const success = await this.platform.tuyaApi.sendCommand(this.deviceConfig.id, settings_1.DP_CODES.SET_COOLING_TEMP, tuyaTemp);
+        if (success) {
+            this.coolingThresholdTemperature = temp;
+        }
+    }
+}
+exports.HeaterCoolerAccessory = HeaterCoolerAccessory;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { API } from 'homebridge';
+declare const _default: (api: API) => void;
+export default _default;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("./settings");
+const platform_1 = require("./platform");
+exports.default = (api) => {
+    api.registerPlatform(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, platform_1.TuyaPoolHeatPumpPlatform);
+};

package/dist/platform.d.ts

@@ -0,0 +1,26 @@
+import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, Service, Characteristic } from 'homebridge';
+import { TuyaPoolHeatPumpConfig, TuyaDeviceStatus } from './settings';
+import { TuyaApi } from './tuyaApi';
+type StatusCallback = (status: TuyaDeviceStatus[]) => void;
+export declare class TuyaPoolHeatPumpPlatform implements DynamicPlatformPlugin {
+    readonly Service: typeof Service;
+    readonly Characteristic: typeof Characteristic;
+    readonly accessories: PlatformAccessory[];
+    readonly api: API;
+    readonly log: Logger;
+    readonly config: TuyaPoolHeatPumpConfig;
+    tuyaApi: TuyaApi;
+    private readonly pollInterval;
+    private pollTimer;
+    private readonly statusCallbacks;
+    constructor(log: Logger, config: TuyaPoolHeatPumpConfig, api: API);
+    configureAccessory(accessory: PlatformAccessory): void;
+    discoverDevices(): Promise<void>;
+    private authenticateWithRetry;
+    private scheduleReconnect;
+    private registerDevice;
+    private startPolling;
+    private pollDeviceStatus;
+    registerStatusCallback(deviceId: string, callback: StatusCallback): void;
+}
+export {};

package/dist/platform.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuyaPoolHeatPumpPlatform = void 0;
+const settings_1 = require("./settings");
+const tuyaApi_1 = require("./tuyaApi");
+const thermostatAccessory_1 = require("./thermostatAccessory");
+const heaterCoolerAccessory_1 = require("./heaterCoolerAccessory");
+class TuyaPoolHeatPumpPlatform {
+    Service;
+    Characteristic;
+    accessories = [];
+    api;
+    log;
+    config;
+    tuyaApi;
+    pollInterval;
+    pollTimer = null;
+    statusCallbacks = new Map();
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config;
+        this.api = api;
+        this.Service = api.hap.Service;
+        this.Characteristic = api.hap.Characteristic;
+        this.pollInterval = config.options?.pollInterval || settings_1.DEFAULT_POLL_INTERVAL;
+        this.log.debug('Finished initializing platform:', config.name);
+        api.on('didFinishLaunching', () => {
+            this.log.debug('Executed didFinishLaunching callback');
+            this.discoverDevices();
+        });
+        api.on('shutdown', () => {
+            this.log.debug('Homebridge is shutting down');
+            if (this.pollTimer) {
+                clearInterval(this.pollTimer);
+            }
+        });
+    }
+    configureAccessory(accessory) {
+        this.log.info('Loading accessory from cache:', accessory.displayName);
+        this.accessories.push(accessory);
+    }
+    async discoverDevices() {
+        if (!this.config.options) {
+            this.log.error('No options configured. Please configure the plugin.');
+            return;
+        }
+        if (!this.config.devices || this.config.devices.length === 0) {
+            this.log.warn('No devices configured. Please add devices in the config.');
+            return;
+        }
+        // Initialize Tuya API
+        this.tuyaApi = new tuyaApi_1.TuyaApi(this.config.options, this.log);
+        const authenticated = await this.authenticateWithRetry(3, 10000);
+        if (!authenticated) {
+            this.log.error('Failed to authenticate after retries. Will keep trying in background.');
+            this.scheduleReconnect();
+            return;
+        }
+        // Register devices
+        for (const deviceConfig of this.config.devices) {
+            this.registerDevice(deviceConfig);
+        }
+        // Start polling for status updates
+        this.startPolling();
+    }
+    async authenticateWithRetry(maxRetries, delayMs) {
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.tuyaApi.authenticate();
+                return true;
+            }
+            catch (error) {
+                this.log.warn(`Authentication attempt ${attempt}/${maxRetries} failed:`, error);
+                if (attempt < maxRetries) {
+                    this.log.info(`Retrying in ${delayMs / 1000} seconds...`);
+                    await new Promise(resolve => setTimeout(resolve, delayMs));
+                }
+            }
+        }
+        return false;
+    }
+    scheduleReconnect() {
+        const reconnectDelay = 60000; // 1 minute
+        this.log.info(`Scheduling reconnection attempt in ${reconnectDelay / 1000} seconds...`);
+        setTimeout(async () => {
+            this.log.info('Attempting to reconnect to Tuya API...');
+            const authenticated = await this.authenticateWithRetry(3, 10000);
+            if (authenticated) {
+                this.log.info('Reconnection successful!');
+                // Register devices if not already done
+                for (const deviceConfig of this.config.devices) {
+                    this.registerDevice(deviceConfig);
+                }
+                this.startPolling();
+            }
+            else {
+                this.scheduleReconnect();
+            }
+        }, reconnectDelay);
+    }
+    registerDevice(deviceConfig) {
+        const uuid = this.api.hap.uuid.generate(deviceConfig.id);
+        const existingAccessory = this.accessories.find(acc => acc.UUID === uuid);
+        if (existingAccessory) {
+            this.log.info('Restoring existing accessory from cache:', existingAccessory.displayName);
+            existingAccessory.context.device = deviceConfig;
+            if (deviceConfig.accessoryType === 'thermostat') {
+                new thermostatAccessory_1.ThermostatAccessory(this, existingAccessory, deviceConfig);
+            }
+            else {
+                new heaterCoolerAccessory_1.HeaterCoolerAccessory(this, existingAccessory, deviceConfig);
+            }
+        }
+        else {
+            this.log.info('Adding new accessory:', deviceConfig.name);
+            const accessory = new this.api.platformAccessory(deviceConfig.name, uuid);
+            accessory.context.device = deviceConfig;
+            if (deviceConfig.accessoryType === 'thermostat') {
+                new thermostatAccessory_1.ThermostatAccessory(this, accessory, deviceConfig);
+            }
+            else {
+                new heaterCoolerAccessory_1.HeaterCoolerAccessory(this, accessory, deviceConfig);
+            }
+            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+        }
+    }
+    startPolling() {
+        this.log.info(`Starting status polling every ${this.pollInterval / 1000} seconds`);
+        this.pollTimer = setInterval(async () => {
+            for (const accessory of this.accessories) {
+                const deviceConfig = accessory.context.device;
+                if (deviceConfig) {
+                    try {
+                        await this.pollDeviceStatus(deviceConfig.id);
+                    }
+                    catch (error) {
+                        this.log.error(`Failed to poll device ${deviceConfig.id}:`, error);
+                    }
+                }
+            }
+        }, this.pollInterval);
+    }
+    async pollDeviceStatus(deviceId) {
+        try {
+            const status = await this.tuyaApi.getDeviceStatus(deviceId);
+            this.log.debug(`Device ${deviceId} status:`, JSON.stringify(status));
+            // Call registered callback for this device
+            const callback = this.statusCallbacks.get(deviceId);
+            if (callback) {
+                callback(status);
+            }
+        }
+        catch (error) {
+            this.log.error(`Failed to get status for device ${deviceId}:`, error);
+        }
+    }
+    registerStatusCallback(deviceId, callback) {
+        this.statusCallbacks.set(deviceId, callback);
+    }
+}
+exports.TuyaPoolHeatPumpPlatform = TuyaPoolHeatPumpPlatform;

package/dist/settings.d.ts

@@ -0,0 +1,81 @@
+import { PlatformConfig } from 'homebridge';
+export declare const PLATFORM_NAME = "TuyaPoolHeatPump";
+export declare const PLUGIN_NAME = "homebridge-tuya-pool-heater";
+export declare const TUYA_ENDPOINTS: Record<string, string>;
+export declare const DEFAULT_POLL_INTERVAL = 30000;
+export declare const TEMP_SCALE = 10;
+export declare const TEMP_RANGES: {
+    readonly heating: {
+        readonly min: 5;
+        readonly max: 55;
+    };
+    readonly cooling: {
+        readonly min: 5;
+        readonly max: 35;
+    };
+    readonly auto: {
+        readonly min: 5;
+        readonly max: 40;
+    };
+};
+export declare const DP_CODES: {
+    readonly SWITCH: "switch";
+    readonly MODE: "mode";
+    readonly TEMP_CURRENT: "temp_current";
+    readonly SET_HEATING_TEMP: "set_heating_temp";
+    readonly SET_COOLING_TEMP: "set_cold_temp";
+    readonly SET_AUTO_TEMP: "set_auto_temp";
+};
+export declare const TUYA_MODES: {
+    readonly AUTO: "Auto";
+    readonly HEATING_SMART: "Heating_Smart";
+    readonly HEATING_POWERFUL: "Heating_Powerful";
+    readonly HEATING_SILENT: "Heating_Silent";
+    readonly COOLING_SMART: "Cooling_Smart";
+    readonly COOLING_POWERFUL: "Cooling_Powerful";
+    readonly COOLING_SILENT: "Cooling_Silent";
+};
+export type TuyaMode = typeof TUYA_MODES[keyof typeof TUYA_MODES];
+export type AccessoryType = 'thermostat' | 'heatercooler';
+export interface TempRangeConfig {
+    min: number;
+    max: number;
+}
+export interface DeviceConfig {
+    id: string;
+    name: string;
+    accessoryType: AccessoryType;
+    heatingRange?: TempRangeConfig;
+    coolingRange?: TempRangeConfig;
+    autoRange?: TempRangeConfig;
+}
+export interface PluginOptions {
+    accessId: string;
+    accessKey: string;
+    endpoint: string;
+    username: string;
+    password: string;
+    countryCode: number;
+    pollInterval?: number;
+}
+export interface TuyaPoolHeatPumpConfig extends PlatformConfig {
+    options: PluginOptions;
+    devices: DeviceConfig[];
+}
+export interface TuyaDeviceStatus {
+    code: string;
+    value: boolean | number | string;
+}
+export interface HeatPumpState {
+    active: boolean;
+    mode: TuyaMode;
+    currentTemperature: number;
+    targetHeatingTemperature: number;
+    targetCoolingTemperature: number;
+    targetAutoTemperature: number;
+}
+export declare function isHeatingMode(mode: string): boolean;
+export declare function isCoolingMode(mode: string): boolean;
+export declare function isAutoMode(mode: string): boolean;
+export declare function tuyaTempToCelsius(value: number): number;
+export declare function celsiusToTuyaTemp(value: number): number;

package/dist/settings.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TUYA_MODES = exports.DP_CODES = exports.TEMP_RANGES = exports.TEMP_SCALE = exports.DEFAULT_POLL_INTERVAL = exports.TUYA_ENDPOINTS = exports.PLUGIN_NAME = exports.PLATFORM_NAME = void 0;
+exports.isHeatingMode = isHeatingMode;
+exports.isCoolingMode = isCoolingMode;
+exports.isAutoMode = isAutoMode;
+exports.tuyaTempToCelsius = tuyaTempToCelsius;
+exports.celsiusToTuyaTemp = celsiusToTuyaTemp;
+exports.PLATFORM_NAME = 'TuyaPoolHeatPump';
+exports.PLUGIN_NAME = 'homebridge-tuya-pool-heater';
+// Tuya API Endpoints by region
+exports.TUYA_ENDPOINTS = {
+    us: 'https://openapi.tuyaus.com',
+    eu: 'https://openapi.tuyaeu.com',
+    cn: 'https://openapi.tuyacn.com',
+    in: 'https://openapi.tuyain.com',
+};
+// Default polling interval in milliseconds
+exports.DEFAULT_POLL_INTERVAL = 30000;
+// Temperature scaling factor (Tuya stores temps as value * 10)
+exports.TEMP_SCALE = 10;
+// Temperature ranges per mode (in Celsius)
+exports.TEMP_RANGES = {
+    heating: { min: 5, max: 55 },
+    cooling: { min: 5, max: 35 },
+    auto: { min: 5, max: 40 },
+};
+// Tuya DP codes for pool heat pumps
+exports.DP_CODES = {
+    SWITCH: 'switch',
+    MODE: 'mode',
+    TEMP_CURRENT: 'temp_current',
+    SET_HEATING_TEMP: 'set_heating_temp',
+    SET_COOLING_TEMP: 'set_cold_temp',
+    SET_AUTO_TEMP: 'set_auto_temp',
+};
+// Tuya mode values
+exports.TUYA_MODES = {
+    AUTO: 'Auto',
+    HEATING_SMART: 'Heating_Smart',
+    HEATING_POWERFUL: 'Heating_Powerful',
+    HEATING_SILENT: 'Heating_Silent',
+    COOLING_SMART: 'Cooling_Smart',
+    COOLING_POWERFUL: 'Cooling_Powerful',
+    COOLING_SILENT: 'Cooling_Silent',
+};
+// Helper to check if mode is heating
+function isHeatingMode(mode) {
+    return mode.toLowerCase().includes('heating');
+}
+// Helper to check if mode is cooling
+function isCoolingMode(mode) {
+    return mode.toLowerCase().includes('cooling');
+}
+// Helper to check if mode is auto
+function isAutoMode(mode) {
+    return mode.toLowerCase() === 'auto';
+}
+// Convert Tuya temperature to Celsius
+function tuyaTempToCelsius(value) {
+    return value / exports.TEMP_SCALE;
+}
+// Convert Celsius to Tuya temperature
+function celsiusToTuyaTemp(value) {
+    return Math.round(value * exports.TEMP_SCALE);
+}

package/dist/settings.test.d.ts

@@ -0,0 +1 @@
+export {};