homebridge-tuya-plus 3.6.0 → 3.8.0

package/config.schema.json

@@ -260,14 +260,14 @@
               "type": "integer",
               "placeholder": "255",
               "condition": {
-                "functionBody": "return model.devices && model.devices[arrayIndices] && ['RGBTWLight','RGBTWOutlet', 'FanLight'].includes(model.devices[arrayIndices].type);"
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['TWLight','RGBTWLight','RGBTWOutlet', 'FanLight'].includes(model.devices[arrayIndices].type);"
               }
             },
             "scaleWhiteColor": {
               "type": "integer",
               "placeholder": "255",
               "condition": {
-                "functionBody": "return model.devices && model.devices[arrayIndices] && ['RGBTWLight','RGBTWOutlet'].includes(model.devices[arrayIndices].type);"
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['TWLight','RGBTWLight','RGBTWOutlet'].includes(model.devices[arrayIndices].type);"
               }
             },
             "outletCount": {

package/lib/BaseAccessory.js

@@ -82,13 +82,19 @@ class BaseAccessory {
     setMultiStateLegacy(dps, callback) {
         //Adding back the original set multistate command as the multistate command from PR #267 Breaks the Fan Code by splitting the command into two.
         //For devices like the DETA Smart Fan Controller Switch that by default set the speed as 3 the new code in the setMultiState function causes issues.
-        if (!this.device.connected) return callback(true);
+        if (!this.device.connected) {
+            this.log.debug(`${this.device.context.name}: skipping write, device not connected`);
+            return callback && callback();
+        }
         const ret = this.device.update(dps);
         callback && callback(!ret);
     }
 
     setMultiState(dps, callback) {
-        if (!this.device.connected) return callback(true);
+        if (!this.device.connected) {
+            this.log.debug(`${this.device.context.name}: skipping write, device not connected`);
+            return callback && callback();
+        }
         for (const dp in dps) {
             if (dps.hasOwnProperty(dp) && dps[dp] !== this.device.state[dp]){
                 this.__ret = this.device.update({[dp.toString()] : dps[dp]});
@@ -121,7 +127,10 @@ class BaseAccessory {
     }
 
     setMultiStateAsync(dps) {
-        if (!this.device.connected) throw new Error('Not connected');
+        if (!this.device.connected) {
+            this.log.debug(`${this.device.context.name}: skipping write, device not connected`);
+            return;
+        }
         for (const dp in dps) {
             if (dps.hasOwnProperty(dp) && dps[dp] !== this.device.state[dp]) {
                 this.device.update({[dp.toString()]: dps[dp]});
@@ -130,7 +139,10 @@ class BaseAccessory {
     }
 
     setMultiStateLegacyAsync(dps) {
-        if (!this.device.connected) throw new Error('Not connected');
+        if (!this.device.connected) {
+            this.log.debug(`${this.device.context.name}: skipping write, device not connected`);
+            return;
+        }
         this.device.update(dps);
     }
 

package/lib/RGBTWLightAccessory.js

@@ -1,5 +1,8 @@
 const BaseAccessory = require('./BaseAccessory');
 
+const DEFAULT_MIN_WHITE_COLOR = 140;
+const DEFAULT_MAX_WHITE_COLOR = 400;
+
 class RGBTWLightAccessory extends BaseAccessory {
     static getCategory(Categories) {
         return Categories.LIGHTBULB;
@@ -28,6 +31,9 @@ class RGBTWLightAccessory extends BaseAccessory {
         this.dpColorTemperature = this._getCustomDP(this.device.context.dpColorTemperature) || '4';
         this.dpColor = this._getCustomDP(this.device.context.dpColor) || '5';
 
+        this.minWhiteColor = this.device.context.minWhiteColor ?? DEFAULT_MIN_WHITE_COLOR;
+        this.maxWhiteColor = this.device.context.maxWhiteColor ?? DEFAULT_MAX_WHITE_COLOR;
+
         this._detectColorFunction(dps[this.dpColor]);
 
         this.cmdWhite = 'white';
@@ -57,10 +63,10 @@ class RGBTWLightAccessory extends BaseAccessory {
 
         const characteristicColorTemperature = service.getCharacteristic(Characteristic.ColorTemperature)
             .setProps({
-                minValue: this.device.context.minWhiteColor,
-                maxValue: this.device.context.maxWhiteColor
+                minValue: this.minWhiteColor,
+                maxValue: this.maxWhiteColor
             })
-            .updateValue(dps[this.dpMode] === this.cmdWhite ? this.convertColorTemperatureFromTuyaToHomeKit(dps[this.dpColorTemperature]) : this.device.context.minWhiteColor)
+            .updateValue(dps[this.dpMode] === this.cmdWhite ? this.convertColorTemperatureFromTuyaToHomeKit(dps[this.dpColorTemperature]) : this.minWhiteColor)
             .onGet(() => this.getColorTemperature())
             .onSet(value => this.setColorTemperature(value));
 
@@ -119,9 +125,9 @@ class RGBTWLightAccessory extends BaseAccessory {
                         if (oldColor.b !== newColor.b) characteristicBrightness.updateValue(newColor.b);
                         if (oldColor.h !== newColor.h) characteristicHue.updateValue(newColor.h);
                         if (oldColor.s !== newColor.s) characteristicSaturation.updateValue(newColor.s);
-                        if (characteristicColorTemperature.value !== this.device.context.minWhiteColor) characteristicColorTemperature.updateValue(this.device.context.minWhiteColor);
+                        if (characteristicColorTemperature.value !== this.minWhiteColor) characteristicColorTemperature.updateValue(this.minWhiteColor);
                     } else if (changes[this.dpMode]) {
-                        if (characteristicColorTemperature.value !== this.device.context.minWhiteColor) characteristicColorTemperature.updateValue(this.device.context.minWhiteColor);
+                        if (characteristicColorTemperature.value !== this.minWhiteColor) characteristicColorTemperature.updateValue(this.minWhiteColor);
                     }
             }
         });
@@ -139,7 +145,7 @@ class RGBTWLightAccessory extends BaseAccessory {
 
     getColorTemperature() {
         this.log.debug(`getColorTemperature`);
-        if (this.device.state[this.dpMode] !== this.cmdWhite) return this.device.context.minWhiteColor;
+        if (this.device.state[this.dpMode] !== this.cmdWhite) return this.minWhiteColor;
         return this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature]);
     }
 
@@ -204,7 +210,7 @@ class RGBTWLightAccessory extends BaseAccessory {
                 if (!(this.device.state[this.dpMode] === this.cmdWhite && isSham)) {
                     this.setMultiStateAsync({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
                 }
-                this.characteristicColorTemperature.updateValue(this.device.context.minWhiteColor);
+                this.characteristicColorTemperature.updateValue(this.minWhiteColor);
 
                 resolvers.forEach(r => r());
             }, 500);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "description": "A community-maintained Homebridge plugin for controlling Tuya devices locally over LAN. Includes new features, fixes, and updated device support.",
   "main": "index.js",
   "scripts": {

package/test/BaseAccessory.test.js

@@ -178,10 +178,11 @@ describe('setStateAsync', () => {
         expect(device.update).not.toHaveBeenCalled();
     });
 
-    test('throws when device is not connected', () => {
+    test('skips silently when device is not connected (issue #34)', () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
-        expect(() => instance.setStateAsync('1', true)).toThrow('Not connected');
+        expect(() => instance.setStateAsync('1', true)).not.toThrow();
+        expect(device.update).not.toHaveBeenCalled();
     });
 });
 
@@ -199,6 +200,13 @@ describe('setMultiStateAsync', () => {
         instance.setMultiStateAsync({ '1': true, '2': 50 });
         expect(device.update).not.toHaveBeenCalled();
     });
+
+    test('skips silently when device is not connected (issue #34)', () => {
+        const { instance, device } = make({ '1': false });
+        device.connected = false;
+        expect(() => instance.setMultiStateAsync({ '1': true, '2': 50 })).not.toThrow();
+        expect(device.update).not.toHaveBeenCalled();
+    });
 });
 
 describe('setMultiStateLegacyAsync', () => {
@@ -208,6 +216,13 @@ describe('setMultiStateLegacyAsync', () => {
         expect(device.update).toHaveBeenCalledTimes(1);
         expect(device.update).toHaveBeenCalledWith({ '1': true, '3': '2' });
     });
+
+    test('skips silently when device is not connected (issue #34)', () => {
+        const { instance, device } = make();
+        device.connected = false;
+        expect(() => instance.setMultiStateLegacyAsync({ '1': true })).not.toThrow();
+        expect(device.update).not.toHaveBeenCalled();
+    });
 });
 
 describe('getDividedStateAsync', () => {
@@ -222,6 +237,34 @@ describe('getDividedStateAsync', () => {
     });
 });
 
+describe('setMultiState (legacy callback)', () => {
+    test('skips silently and invokes callback without error when not connected (issue #34)', () => {
+        const { instance, device } = make({ '1': false });
+        device.connected = false;
+        const cb = jest.fn();
+        instance.setMultiState({ '1': true }, cb);
+        expect(device.update).not.toHaveBeenCalled();
+        expect(cb).toHaveBeenCalledWith();
+    });
+
+    test('tolerates a missing callback when not connected', () => {
+        const { instance, device } = make({ '1': false });
+        device.connected = false;
+        expect(() => instance.setMultiState({ '1': true })).not.toThrow();
+    });
+});
+
+describe('setMultiStateLegacy (legacy callback)', () => {
+    test('skips silently and invokes callback without error when not connected (issue #34)', () => {
+        const { instance, device } = make();
+        device.connected = false;
+        const cb = jest.fn();
+        instance.setMultiStateLegacy({ '1': true }, cb);
+        expect(device.update).not.toHaveBeenCalled();
+        expect(cb).toHaveBeenCalledWith();
+    });
+});
+
 // ---------------------------------------------------------------------------
 // Utility helpers
 // ---------------------------------------------------------------------------

package/test/RGBTWLightAccessory.test.js

@@ -5,7 +5,7 @@ const { makeInstance, makeMockCharacteristic } = require('./support/mocks');
 
 function makeLight(state = {}, context = {}) {
     const result = makeInstance(RGBTWLightAccessory, state, { colorFunction: 'HEXHSB', ...context });
-    const { instance } = result;
+    const { instance, device } = result;
 
     // Set up the state that _registerCharacteristics would normally establish
     instance.dpPower = '1';
@@ -16,6 +16,8 @@ function makeLight(state = {}, context = {}) {
     instance.cmdWhite = 'white';
     instance.cmdColor = 'colour';
     instance.colorFunction = 'HEXHSB';
+    instance.minWhiteColor = device.context.minWhiteColor ?? 140;
+    instance.maxWhiteColor = device.context.maxWhiteColor ?? 400;
 
     // Provide the cross-characteristic references _setHueSaturation writes to
     instance.characteristicColorTemperature = makeMockCharacteristic(0);
@@ -64,8 +66,7 @@ describe('RGBTWLightAccessory.setBrightness', () => {
 // ---------------------------------------------------------------------------
 describe('RGBTWLightAccessory.getColorTemperature', () => {
     test('returns minWhiteColor when in color mode', () => {
-        const { instance, device } = makeLight({ '2': 'colour' });
-        device.context.minWhiteColor = 140;
+        const { instance } = makeLight({ '2': 'colour' }, { minWhiteColor: 140 });
         expect(instance.getColorTemperature()).toBe(140);
     });
 
@@ -74,6 +75,35 @@ describe('RGBTWLightAccessory.getColorTemperature', () => {
         // convertColorTemperatureFromTuyaToHomeKit(255) = 140
         expect(instance.getColorTemperature()).toBe(140);
     });
+
+    test('returns a finite default when minWhiteColor is not configured (issue #34)', () => {
+        const { instance } = makeLight({ '2': 'colour' });
+        const result = instance.getColorTemperature();
+        expect(typeof result).toBe('number');
+        expect(Number.isFinite(result)).toBe(true);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// setColorTemperature
+// ---------------------------------------------------------------------------
+describe('RGBTWLightAccessory.setColorTemperature', () => {
+    test('does not throw when device is not connected (issue #34)', () => {
+        const { instance, device } = makeLight({ '2': 'white', '4': 255 });
+        instance.characteristicHue = makeMockCharacteristic(0);
+        instance.characteristicSaturation = makeMockCharacteristic(0);
+        device.connected = false;
+        expect(() => instance.setColorTemperature(200)).not.toThrow();
+        expect(device.update).not.toHaveBeenCalled();
+    });
+
+    test('writes color temperature when device is connected', () => {
+        const { instance, device } = makeLight({ '2': 'white', '4': 255 });
+        instance.characteristicHue = makeMockCharacteristic(0);
+        instance.characteristicSaturation = makeMockCharacteristic(0);
+        instance.setColorTemperature(200);
+        expect(device.update).toHaveBeenCalled();
+    });
 });
 
 // ---------------------------------------------------------------------------
@@ -133,11 +163,21 @@ describe('RGBTWLightAccessory._setHueSaturation', () => {
     });
 
     test('updates characteristicColorTemperature to minWhiteColor after firing', async () => {
-        const { instance } = makeLight({ '2': 'colour', '5': '00000000b46464' });
-        instance.device.context.minWhiteColor = 140;
+        const { instance } = makeLight({ '2': 'colour', '5': '00000000b46464' }, { minWhiteColor: 140 });
         const p = instance.setHue(180);
         jest.advanceTimersByTime(500);
         await p;
         expect(instance.characteristicColorTemperature.updateValue).toHaveBeenCalledWith(140);
     });
+
+    test('updates characteristicColorTemperature to a finite default when minWhiteColor unset (issue #34)', async () => {
+        const { instance } = makeLight({ '2': 'colour', '5': '00000000b46464' });
+        const p = instance.setHue(180);
+        jest.advanceTimersByTime(500);
+        await p;
+        const calls = instance.characteristicColorTemperature.updateValue.mock.calls;
+        const lastValue = calls[calls.length - 1][0];
+        expect(typeof lastValue).toBe('number');
+        expect(Number.isFinite(lastValue)).toBe(true);
+    });
 });