@bldgblocks/node-red-contrib-control 0.1.34 → 0.1.36

package/nodes/delay-block.js

@@ -5,13 +5,12 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
 
-        node.runtime = {
-            name: config.name,
-            state: false,
-            desired: false,
-            delayOn: parseFloat(config.delayOn) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1),
-            delayOff: parseFloat(config.delayOff) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1)
-        };
+        // Initialize state
+        node.name = config.name;
+        node.state = false;
+        node.desired = false;
+        node.delayOn = parseFloat(config.delayOn) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
+        node.delayOff = parseFloat(config.delayOff) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
 
         let timeoutId = null;
         node.isBusy = false;
@@ -21,7 +20,7 @@ module.exports = function(RED) {
             
             // Guard against invalid msg
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }   
@@ -32,7 +31,7 @@ module.exports = function(RED) {
                 // Check busy lock
                 if (node.isBusy) {
                     // Update status to let user know they are pushing too fast
-                    node.status({ fill: "yellow", shape: "ring", text: "busy - dropped msg" });
+                    utils.setStatusBusy(node, "busy - dropped msg");
                     if (done) done(); 
                     return;
                 }
@@ -47,21 +46,21 @@ module.exports = function(RED) {
                     utils.requiresEvaluation(config.delayOnType) 
                         ? utils.evaluateNodeProperty(config.delayOn, config.delayOnType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.delayOn),
+                        : Promise.resolve(node.delayOn),
                 );
                 
                 evaluations.push(
                     utils.requiresEvaluation(config.delayOffType) 
                         ? utils.evaluateNodeProperty(config.delayOff, config.delayOffType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.delayOff),
+                        : Promise.resolve(node.delayOff),
                 );
 
                 const results = await Promise.all(evaluations);   
 
                 // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.runtime.delayOn = results[0] * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
-                if (!isNaN(results[1])) node.runtime.delayOff = results[1] * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);         
+                if (!isNaN(results[0])) node.delayOn = results[0] * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
+                if (!isNaN(results[1])) node.delayOff = results[1] * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);         
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -72,35 +71,41 @@ module.exports = function(RED) {
             }
 
             // Acceptable fallbacks
-            if (isNaN(node.runtime.delayOn) || node.runtime.delayOn < 0) {
-                node.runtime.delayOn = 1000;
-                node.status({ fill: "red", shape: "ring", text: "invalid delayOn" });
+            if (isNaN(node.delayOn) || node.delayOn < 0) {
+                node.delayOn = 1000;
+                utils.setStatusError(node, "invalid delayOn");
             }
-            if (isNaN(node.runtime.delayOff) || node.runtime.delayOff < 0) {
-                node.runtime.delayOff = 1000;
-                node.status({ fill: "red", shape: "ring", text: "invalid delayOff" });
+            if (isNaN(node.delayOff) || node.delayOff < 0) {
+                node.delayOff = 1000;
+                utils.setStatusError(node, "invalid delayOff");
             }
 
             if (msg.hasOwnProperty("context")) {
                 if (msg.context === "reset") {
-                    if (!msg.hasOwnProperty("payload") || typeof msg.payload !== "boolean") {
-                        node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                    if (!msg.hasOwnProperty("payload")) {
+                        utils.setStatusError(node, "missing payload");
+                        if (done) done();
+                        return;
+                    }
+                    const boolVal = utils.validateBoolean(msg.payload);
+                    if (!boolVal.valid) {
+                        utils.setStatusError(node, boolVal.error);
                         if (done) done();
                         return;
                     }
-                    if (msg.payload === true) {
+                    if (boolVal.value === true) {
                         if (timeoutId) {
                             clearTimeout(timeoutId);
                             timeoutId = null;
                         }
-                        node.runtime.state = false;
-                        node.status({ fill: "green", shape: "dot", text: "reset" });
+                        node.state = false;
+                        utils.setStatusOK(node, "reset");
                     }
                     if (done) done();
                     return;
                 } else if (msg.context === "delayOn") {
                     if (!msg.hasOwnProperty("payload")) {
-                        node.status({ fill: "red", shape: "ring", text: "missing payload for delayOn" });
+                        utils.setStatusError(node, "missing payload for delayOn");
                         if (done) done();
                         return;
                     }
@@ -108,17 +113,17 @@ module.exports = function(RED) {
                     const newDelayOnMultiplier = msg.units === "seconds" ? 1000 : msg.units === "minutes" ? 60000 : 1;
                     newDelayOn *= newDelayOnMultiplier;
                     if (isNaN(newDelayOn) || newDelayOn < 0) {
-                        node.status({ fill: "red", shape: "ring", text: "invalid delayOn" });
+                        utils.setStatusError(node, "invalid delayOn");
                         if (done) done();
                         return;
                     }
-                    node.runtime.delayOn = newDelayOn;
-                    node.status({ fill: "green", shape: "dot", text: `delayOn: ${newDelayOn.toFixed(0)} ms` });
+                    node.delayOn = newDelayOn;
+                    utils.setStatusOK(node, `delayOn: ${newDelayOn.toFixed(0)} ms`);
                     if (done) done();
                     return;
                 } else if (msg.context === "delayOff") {
                     if (!msg.hasOwnProperty("payload")) {
-                        node.status({ fill: "red", shape: "ring", text: "missing payload for delayOff" });
+                        utils.setStatusError(node, "missing payload for delayOff");
                         if (done) done();
                         return;
                     }
@@ -126,81 +131,81 @@ module.exports = function(RED) {
                     const newDelayOffMultiplier = msg.units === "seconds" ? 1000 : msg.units === "minutes" ? 60000 : 1;
                     newDelayOff *= newDelayOffMultiplier;
                     if (isNaN(newDelayOff) || newDelayOff < 0) {
-                        node.status({ fill: "red", shape: "ring", text: "invalid delayOff" });
+                        utils.setStatusError(node, "invalid delayOff");
                         if (done) done();
                         return;
                     }
-                    node.runtime.delayOff = newDelayOff;
-                    node.status({ fill: "green", shape: "dot", text: `delayOff: ${newDelayOff.toFixed(0)} ms` });
+                    node.delayOff = newDelayOff;
+                    utils.setStatusOK(node, `delayOff: ${newDelayOff.toFixed(0)} ms`);
                     if (done) done();
                     return;
                 }
-                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                utils.setStatusWarn(node, "unknown context");
                 if (done) done();
                 return;
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             const inputValue = msg.payload;
             if (typeof inputValue !== "boolean") {
-                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                utils.setStatusError(node, "invalid payload");
                 if (done) done();
                 return;
             }
 
-            if (!node.runtime.state && inputValue === true) {
-                if (node.runtime.desired) {
+            if (!node.state && inputValue === true) {
+                if (node.desired) {
                     if (done) done();
                     return;
                 }
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                 }
-                node.status({ fill: "blue", shape: "ring", text: `awaiting true` });
-                node.runtime.desired = true;
+                utils.setStatusUnchanged(node, "awaiting true");
+                node.desired = true;
                 timeoutId = setTimeout(() => {
-                    node.runtime.state = true;
+                    node.state = true;
                     msg.payload = true;
                     delete msg.context;
-                    node.status({ fill: "blue", shape: "dot", text: `in: true, out: true` });
+                    utils.setStatusChanged(node, "in: true, out: true");
                     send(msg);
                     timeoutId = null;
-                }, node.runtime.delayOn);
-            } else if (node.runtime.state && inputValue === false) {
-                if (node.runtime.desired === false) {
+                }, node.delayOn);
+            } else if (node.state && inputValue === false) {
+                if (node.desired === false) {
                     if (done) done();
                     return;
                 }
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                 }
-                node.status({ fill: "blue", shape: "ring", text: `awaiting false` });
-                node.runtime.desired = false;
+                utils.setStatusUnchanged(node, "awaiting false");
+                node.desired = false;
                 timeoutId = setTimeout(() => {
-                    node.runtime.state = false;
+                    node.state = false;
                     msg.payload = false;
                     delete msg.context;
-                    node.status({ fill: "blue", shape: "dot", text: `in: false, out: false` });
+                    utils.setStatusChanged(node, "in: false, out: false");
                     send(msg);
                     timeoutId = null;
-                }, node.runtime.delayOff);
+                }, node.delayOff);
             } else {
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                     timeoutId = null;
-                    node.status({ fill: "blue", shape: "ring", text: `canceled awaiting ${node.runtime.state}` });
+                    utils.setStatusUnchanged(node, `canceled awaiting ${node.state}`);
                 } else {
-                    node.status({ fill: "blue", shape: "ring", text: `no change` });
+                    utils.setStatusUnchanged(node, "no change");
                 }
                 
                 // No state change, pass the message through
-                node.runtime.state = inputValue;
-                desired = inputValue;
+                node.state = inputValue;
+                node.desired = inputValue;
                 send(msg);
             }
 

package/nodes/divide-block.js

@@ -1,114 +1,112 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function DivideBlockNode(config) {
         RED.nodes.createNode(this, config);
         
         const node = this;
         
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            slots: parseInt(config.slots),
-            inputs: Array(config.slots).fill(1).map(x => parseFloat(x)),
-            lastResult: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.slots = parseInt(config.slots);
+        node.inputs = Array(config.slots).fill(1).map(x => parseFloat(x));
+        node.lastResult = null;
 
-        node.status({
-            fill: "green",
-            shape: "dot",
-            text: `name: ${node.runtime.name}, slots: ${node.runtime.slots}`
-        });
+        utils.setStatusOK(node, `name: ${node.name}, slots: ${node.slots}`);
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             // Guard against invalid msg
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
 
             // Check for missing context or payload
             if (!msg.hasOwnProperty("context")) {
-                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                utils.setStatusError(node, "missing context");
                 if (done) done();
                 return;
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             // Handle configuration messages
             if (msg.context === "reset") {
-                if (typeof msg.payload !== "boolean") {
-                    node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                const boolVal = utils.validateBoolean(msg.payload);
+                if (!boolVal.valid) {
+                    utils.setStatusError(node, boolVal.error);
                     if (done) done();
                     return;
                 }
-                if (msg.payload === true) {
-                    node.runtime.inputs = Array(node.runtime.slots).fill(1);
-                    node.runtime.lastResult = null;
-                    node.status({ fill: "green", shape: "dot", text: "state reset" });
+                if (boolVal.value === true) {
+                    node.inputs = Array(node.slots).fill(1);
+                    node.lastResult = null;
+                    utils.setStatusOK(node, "state reset");
                     if (done) done();
                     return;
                 }
             } else if (msg.context === "slots") {
-                let newSlots = parseInt(msg.payload);
-                if (isNaN(newSlots) || newSlots < 1) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid slots" });
+                const slotsVal = utils.validateIntRange(msg.payload, { min: 1 });
+                if (!slotsVal.valid) {
+                    utils.setStatusError(node, slotsVal.error);
                     if (done) done();
                     return;
                 }
-                node.runtime.slots = newSlots;
-                node.runtime.inputs = Array(newSlots).fill(1);
-                node.runtime.lastResult = null;
-                node.status({ fill: "green", shape: "dot", text: `slots: ${node.runtime.slots}` });
+                node.slots = slotsVal.value;
+                node.inputs = Array(newSlots).fill(1);
+                node.lastResult = null;
+                utils.setStatusOK(node, `slots: ${node.slots}`);
                 if (done) done();
                 return;
             } else if (msg.context.startsWith("in")) {
-                let slotIndex = parseInt(msg.context.slice(2)) - 1;
-                if (isNaN(slotIndex) || slotIndex < 0 || slotIndex >= node.runtime.slots) {
-                    node.status({ fill: "red", shape: "ring", text: `invalid input slot ${msg.context}` });
+                const slotVal = utils.validateSlotIndex(msg.context, node.slots);
+                if (!slotVal.valid) {
+                    utils.setStatusError(node, slotVal.error);
                     if (done) done();
                     return;
                 }
+                const slotIndex = slotVal.index - 1;
                 let newValue = parseFloat(msg.payload);
                 if (isNaN(newValue)) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                    utils.setStatusError(node, "invalid input");
                     if (done) done();
                     return;
                 }
                 if (slotIndex > 0 && newValue === 0) {
-                    node.status({ fill: "red", shape: "ring", text: "divide by zero" });
+                    utils.setStatusError(node, "divide by zero");
                     if (done) done();
                     return;
                 }
                 // Handle division by very small numbers approaching zero
                 if (slotIndex > 0 && Math.abs(newValue) < 1e-10) {  // Near-zero check
-                    node.status({ fill: "red", shape: "ring", text: "divide by near-zero" });
+                    utils.setStatusError(node, "divide by near-zero");
                     if (done) done();
                     return;
                 }
-                node.runtime.inputs[slotIndex] = newValue;
+                node.inputs[slotIndex] = newValue;
                 // Calculate division
-                const result = node.runtime.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc / val, 1);
-                const isUnchanged = result === node.runtime.lastResult;
-                node.status({
-                    fill: "blue",
-                    shape: isUnchanged ? "ring" : "dot",
-                    text: `in: ${msg.context}=${newValue.toFixed(2)}, out: ${result.toFixed(2)}`
-                });
-                if (!isUnchanged) {
-                    node.runtime.lastResult = result;
-                    send({ payload: result });
+                const result = node.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc / val, 1);
+                const isUnchanged = result === node.lastResult;
+                const statusText = `in: ${msg.context}=${newValue.toFixed(2)}, out: ${result.toFixed(2)}`;
+                if (isUnchanged) {
+                    utils.setStatusUnchanged(node, statusText);
+                } else {
+                    utils.setStatusChanged(node, statusText);
                 }
+                node.lastResult = result;
+                send({ payload: result });
                 if (done) done();
                 return;
             } else {
-                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                utils.setStatusWarn(node, "unknown context");
                 if (done) done();
                 return;
             }

package/nodes/edge-block.html

@@ -4,7 +4,11 @@
         <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
         <input type="text" id="node-input-name" placeholder="Name">
     </div>
-    <div class="form-row">
+    <div class="form-row">        
+        <label for="node-input-inputProperty" title="Message property to read input from"><i class="fa fa-folder-open"></i> Input Property</label>
+        <input type="text" id="node-input-inputProperty" placeholder="payload">
+    </div>
+    <div class="form-row">        
         <label for="node-input-algorithm" title="Transition to detect (true-to-false or false-to-true)"><i class="fa fa-exchange"></i> Algorithm</label>
         <select id="node-input-algorithm">
             <option value="true-to-false">True to False</option>
@@ -20,6 +24,7 @@
         color: "#301934",
         defaults: {
             name: { value: "" },
+            inputProperty: { value: "payload" },
             algorithm: { value: "true-to-false", required: true }
         },
         inputs: 1,
@@ -36,27 +41,29 @@
 
 <!-- Help Section -->
 <script type="text/markdown" data-help-name="edge-block">
-Detects configured boolean transitions (true-to-false or false-to-true) in `msg.payload`.
+Detects boolean state transitions (true-to-false or false-to-true).
 
 ### Inputs
-: payload (boolean) : Boolean to monitor for transitions.
+: input-property (boolean) : Boolean value to monitor for transitions, read from the configured Input Property.
 : context (string) : Action (`"algorithm"` to set transition type, `"reset"` to clear state). Unknown `msg.context` is ignored.
 : payload (string | boolean) : Transition type (`"true-to-false"`, `"false-to-true"`) for `"algorithm"`, true for `"reset"`.
 
 ### Outputs
-: payload (boolean) : `true` when the specified transition occurs (true-to-false or false-to-true).
+: payload (boolean) : `true` when the specified transition occurs; `false` otherwise.
 
 ### Properties
 : name (string) : Display name in editor.
+: inputProperty (string) : Message property to read input from (default: `payload`). Supports nested properties (e.g., `data.value`).
 : algorithm (string) : Transition to detect (`"true-to-false"`, `"false-to-true"`).
 
 ### Details
-Detects transitions in boolean payloads based on the configured `algorithm`. 
-Outputs `msg.payload` as true only when the specified transition occurs (true-to-false or false-to-true). 
-No output on first input after reset, if no transition occurs, or for non-boolean inputs. 
-Configuration via `msg.context`
-- `"algorithm"` Sets transition type, no output.
-- `"reset"` Clears state, no output.
+Detects transitions in boolean input (read from the configured **Input Property**, default: `msg.payload`) based on the configured `algorithm`.
+Outputs `msg.payload` as true only when the specified transition occurs (true-to-false or false-to-true).
+No output on first input after reset, if no transition occurs, or for non-boolean inputs.
+
+Configuration via `msg.context`:
+- `"algorithm"`: Sets transition type, no output.
+- `"reset"`: Clears state, no output.
 
 ### Status
 - Green (dot): Configuration

package/nodes/edge-block.js

@@ -1,20 +1,18 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function EdgeBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            algorithm: config.algorithm,
-            lastValue: null
-        };
-
-        node.status({
-            fill: "green",
-            shape: "dot",
-            text: `name: ${node.runtime.name || "edge"}, algorithm: ${node.runtime.algorithm}`
-        });
+        // Initialize state
+        node.name = config.name;
+        node.inputProperty = config.inputProperty || "payload";
+        node.algorithm = config.algorithm;
+        node.lastValue = null;
+
+        utils.setStatusOK(node, `name: ${node.name || "edge"}, algorithm: ${node.algorithm}`);
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
@@ -23,7 +21,7 @@ module.exports = function(RED) {
 
             // Guard against invalid message
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
@@ -32,31 +30,37 @@ module.exports = function(RED) {
             if (msg.hasOwnProperty("context") && typeof msg.context === "string") {
                 if (msg.context === "algorithm") {
                     if (!msg.hasOwnProperty("payload")) {
-                        node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                        utils.setStatusError(node, "missing payload");
                         if (done) done();
                         return;
                     }
                     const newAlgorithm = String(msg.payload);
                     if (!validAlgorithms.includes(newAlgorithm)) {
-                        node.status({ fill: "red", shape: "ring", text: "invalid algorithm" });
+                        utils.setStatusError(node, "invalid algorithm");
                         if (done) done();
                         return;
                     }
-                    node.runtime.algorithm = newAlgorithm;
-                    node.status({ fill: "green", shape: "dot", text: `algorithm: ${newAlgorithm}` });
+                    node.algorithm = newAlgorithm;
+                    utils.setStatusOK(node, `algorithm: ${newAlgorithm}`);
                     if (done) done();
                     return;
                 }
 
                 if (msg.context === "reset") {
-                    if (!msg.hasOwnProperty("payload") || typeof msg.payload !== "boolean") {
-                        node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                    if (!msg.hasOwnProperty("payload")) {
+                        utils.setStatusError(node, "missing payload");
                         if (done) done();
                         return;
                     }
-                    if (msg.payload === true) {
-                        node.runtime.lastValue = null;
-                        node.status({ fill: "green", shape: "dot", text: "state reset" });
+                    const boolVal = utils.validateBoolean(msg.payload);
+                    if (!boolVal.valid) {
+                        utils.setStatusError(node, boolVal.error);
+                        if (done) done();
+                        return;
+                    }
+                    if (boolVal.value === true) {
+                        node.lastValue = null;
+                        utils.setStatusOK(node, "state reset");
                         if (done) done();
                         return;
                     }
@@ -66,48 +70,46 @@ module.exports = function(RED) {
                 // Ignore unknown context, process payload
             }
 
-            // Validate payload
-            if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+            // Get input from configured property
+            let inputValue;
+            try {
+                inputValue = RED.util.getMessageProperty(msg, node.inputProperty);
+            } catch (err) {
+                inputValue = undefined;
+            }
+            if (inputValue === undefined) {
+                utils.setStatusError(node, "missing or invalid input property");
                 if (done) done();
                 return;
             }
 
-            if (typeof msg.payload !== "boolean") {
-                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+            if (typeof inputValue !== "boolean") {
+                utils.setStatusError(node, "invalid input");
                 if (done) done();
                 return;
             }
 
-            const currentValue = msg.payload;
-            const lastValue = node.runtime.lastValue;
+            const currentValue = inputValue;
+            const lastValue = node.lastValue;
 
             // Check for transition
             let isTransition = false;
             if (lastValue !== null && lastValue !== undefined) {
-                if (node.runtime.algorithm === "true-to-false" && lastValue === true && currentValue === false) {
+                if (node.algorithm === "true-to-false" && lastValue === true && currentValue === false) {
                     isTransition = true;
-                } else if (node.runtime.algorithm === "false-to-true" && lastValue === false && currentValue === true) {
+                } else if (node.algorithm === "false-to-true" && lastValue === false && currentValue === true) {
                     isTransition = true;
                 }
             }
 
             if (isTransition) {
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: `in: ${currentValue}, out: true`
-                });
+                utils.setStatusChanged(node, `in: ${currentValue}, out: true`);
                 send({ payload: true });
             } else {
-                node.status({
-                    fill: "blue",
-                    shape: "ring",
-                    text: `in: ${currentValue}, out: none`
-                });
+                utils.setStatusUnchanged(node, `in: ${currentValue}, out: none`);
             }
 
-            node.runtime.lastValue = currentValue;
+            node.lastValue = currentValue;
             if (done) done();
         });