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

package/nodes/memory-block.js

@@ -10,16 +10,15 @@ module.exports = function(RED) {
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            writePeriod: config.writePeriod,
-            transferProperty: config.transferProperty,
-            writeOnUpdate: config.writeOnUpdate === true,
-            storedMsg: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.writePeriod = config.writePeriod;
+        node.transferProperty = config.transferProperty;
+        node.writeOnUpdate = config.writeOnUpdate === true;
+        node.storedMsg = null;
 
         // Resolve typed inputs
-        node.runtime.writePeriod = parseFloat(RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node ));
+        node.writePeriod = parseFloat(RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node ));
 
         // File path for persistent storage
         const filePath = path.join(RED.settings.userDir, `memory-${node.id}.json`);
@@ -31,12 +30,12 @@ module.exports = function(RED) {
         async function loadStoredMessage() {
             try {
                 const data = await fs.readFile(filePath, "utf8");
-                node.runtime.storedMsg = JSON.parse(data);
-                const payloadStr = node.runtime.storedMsg[node.runtime.transferProperty] != null ? String(node.runtime.storedMsg[node.runtime.transferProperty]).substring(0, 20) : "null";
-                node.status({ fill: "green", shape: "dot", text: `loaded: ${payloadStr}` });
+                node.storedMsg = JSON.parse(data);
+                const payloadStr = node.storedMsg[node.transferProperty] != null ? String(node.storedMsg[node.transferProperty]).substring(0, 20) : "null";
+                utils.setStatusOK(node, `loaded: ${payloadStr}`);
             } catch (err) {
                 if (err.code !== "ENOENT") {
-                    node.status({ fill: "red", shape: "ring", text: "file error" });
+                    utils.setStatusError(node, "file error");
                 }
             }
         }
@@ -50,7 +49,7 @@ module.exports = function(RED) {
                 }
                 return null;
             } catch (err) {
-                node.status({ fill: "red", shape: "ring", text: "file read error" });
+                utils.setStatusError(node, "file read error");
                 node.error("Failed to read stored message: " + err.message);
                 return null;
             }
@@ -63,13 +62,13 @@ module.exports = function(RED) {
                 await fs.writeFile(filePath, JSON.stringify(lastUpdateMsg));
                 lastUpdateMsg = null;
             } catch (err) {
-                node.status({ fill: "red", shape: "ring", text: "file error" });
+                utils.setStatusError(node, "file error");
                 node.error("Failed to save message: " + err.message);
             }
         }
 
         // Initialize (load only if writeOnUpdate is false)
-        if (!node.runtime.writeOnUpdate) {
+        if (!node.writeOnUpdate) {
             loadStoredMessage().catch(err => {
                 node.error("Failed to load stored message: " + err.message);
             });
@@ -80,14 +79,14 @@ 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;
             }
 
             // Evaluate typed-inputs if needed
             if (utils.requiresEvaluation(config.writePeriodType)) {
-                node.runtime.writePeriod = parseFloat(RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node, msg ));
+                node.writePeriod = parseFloat(RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node, msg ));
             }
 
             // Initialize output array: [Output 1, Output 2]
@@ -96,8 +95,8 @@ module.exports = function(RED) {
             // Handle context
             if (!msg.hasOwnProperty("context") || !msg.context || typeof msg.context !== "string") {
                 // Pass-through message to Output 2
-                const payloadStr = msg[node.runtime.transferProperty] != null ? String(msg[node.runtime.transferProperty]).substring(0, 20) : "null";
-                node.status({ fill: "blue", shape: "dot", text: `in: ${payloadStr}, out2: ${payloadStr}` });
+                const payloadStr = msg[node.transferProperty] != null ? String(msg[node.transferProperty]).substring(0, 20) : "null";
+                utils.setStatusChanged(node, `in: ${payloadStr}, out2: ${payloadStr}`);
                 output[1] = msg;
                 send(output);
                 if (done) done();
@@ -105,30 +104,30 @@ module.exports = function(RED) {
             }
 
             if (msg.context === "update") {
-                if (!msg.hasOwnProperty(node.runtime.transferProperty)) {
-                    node.status({ fill: "red", shape: "ring", text: `missing ${node.runtime.transferProperty}` });
+                if (!msg.hasOwnProperty(node.transferProperty)) {
+                    utils.setStatusError(node, `missing ${node.transferProperty}`);
                     if (done) done();
                     return;
                 }
-                const payloadStr = msg[node.runtime.transferProperty] != null ? String(msg[node.runtime.transferProperty]).substring(0, 20) : "null";
-                if (node.runtime.writeOnUpdate) {
+                const payloadStr = msg[node.transferProperty] != null ? String(msg[node.transferProperty]).substring(0, 20) : "null";
+                if (node.writeOnUpdate) {
                     // Write directly to file, do not store in memory
                     try {
                         fs.writeFile(filePath, JSON.stringify(msg)).catch(err => {
-                            node.status({ fill: "red", shape: "ring", text: "file error" });
+                            utils.setStatusError(node, "file error");
                             node.error("Failed to save message: " + err.message);
                         });
-                        node.status({ fill: "green", shape: "dot", text: `updated: ${payloadStr}` });
+                        utils.setStatusOK(node, `updated: ${payloadStr}`);
                     } catch (err) {
-                        node.status({ fill: "red", shape: "ring", text: "file error" });
+                        utils.setStatusError(node, "file error");
                         node.error("Failed to save message: " + err.message);
                     }
                 } else {
                     // Original behavior: store in memory and context, delay write
-                    node.runtime.storedMsg = RED.util.cloneMessage(msg);
-                    node.context().set("storedMsg", node.runtime.storedMsg);
-                    lastUpdateMsg = node.runtime.storedMsg;
-                    node.status({ fill: "green", shape: "dot", text: `updated: ${payloadStr}` });
+                    node.storedMsg = RED.util.cloneMessage(msg);
+                    node.context().set("storedMsg", node.storedMsg);
+                    lastUpdateMsg = node.storedMsg;
+                    utils.setStatusOK(node, `updated: ${payloadStr}`);
                     if (writeTimeout) clearTimeout(writeTimeout);
                     writeTimeout = setTimeout(() => {
                         saveMessage();
@@ -139,15 +138,15 @@ module.exports = function(RED) {
             }
 
             if (msg.context === "execute") {
-                let storedMsg = node.runtime.writeOnUpdate ? readStoredMessageSync() : node.runtime.storedMsg;
+                let storedMsg = node.writeOnUpdate ? readStoredMessageSync() : node.storedMsg;
                 if (storedMsg !== null) {
                     const outMsg = RED.util.cloneMessage(msg);
-                    outMsg[node.runtime.transferProperty] = storedMsg[node.runtime.transferProperty];
-                    const payloadStr = outMsg[node.runtime.transferProperty] != null ? String(outMsg[node.runtime.transferProperty]).substring(0, 20) : "null";
-                    node.status({ fill: "blue", shape: "dot", text: `in: execute, out2: ${payloadStr}` });
+                    outMsg[node.transferProperty] = storedMsg[node.transferProperty];
+                    const payloadStr = outMsg[node.transferProperty] != null ? String(outMsg[node.transferProperty]).substring(0, 20) : "null";
+                    utils.setStatusChanged(node, `in: execute, out2: ${payloadStr}`);
                     output[1] = outMsg;
                 } else {
-                    node.status({ fill: "blue", shape: "ring", text: `in: execute, out2: null` });
+                    utils.setStatusUnchanged(node, `in: execute, out2: null`);
                     output[1] = { payload: null };
                 }
                 send(output);
@@ -156,51 +155,51 @@ module.exports = function(RED) {
             }
 
             if (msg.context === "executeWithFallback") {
-                let storedMsg = node.runtime.writeOnUpdate ? readStoredMessageSync() : node.runtime.storedMsg;
+                let storedMsg = node.writeOnUpdate ? readStoredMessageSync() : node.storedMsg;
                 if (storedMsg !== null) {
                     const outMsg = RED.util.cloneMessage(msg);
-                    outMsg[node.runtime.transferProperty] = storedMsg[node.runtime.transferProperty];
-                    const payloadStr = outMsg[node.runtime.transferProperty] != null ? String(outMsg[node.runtime.transferProperty]).substring(0, 20) : "null";
-                    node.status({ fill: "blue", shape: "dot", text: `in: executeWithFallback, out2: ${payloadStr}` });
+                    outMsg[node.transferProperty] = storedMsg[node.transferProperty];
+                    const payloadStr = outMsg[node.transferProperty] != null ? String(outMsg[node.transferProperty]).substring(0, 20) : "null";
+                    utils.setStatusChanged(node, `in: executeWithFallback, out2: ${payloadStr}`);
                     output[1] = outMsg;
                 } else {
                     let value;
-                    if (msg.hasOwnProperty(node.runtime.transferProperty)) {
-                        value = msg[node.runtime.transferProperty];
+                    if (msg.hasOwnProperty(node.transferProperty)) {
+                        value = msg[node.transferProperty];
                     }
                     else if (msg.hasOwnProperty("fallback")) {
                         value = msg.fallback;
                     } else {
-                        node.status({ fill: "red", shape: "ring", text: `missing ${node.runtime.transferProperty}` });
+                        utils.setStatusError(node, `missing ${node.transferProperty}`);
                         if (done) done();
                         return;
                     }
                     
-                    if (node.runtime.writeOnUpdate) {
+                    if (node.writeOnUpdate) {
                         // Write directly to file
                         try {
-                            fs.writeFile(filePath, JSON.stringify({ [node.runtime.transferProperty]: value })).catch(err => {
-                                node.status({ fill: "red", shape: "ring", text: "file error" });
+                            fs.writeFile(filePath, JSON.stringify({ [node.transferProperty]: value })).catch(err => {
+                                utils.setStatusError(node, "file error");
                                 node.error("Failed to save message: " + err.message);
                             });
                         } catch (err) {
-                            node.status({ fill: "red", shape: "ring", text: "file error" });
+                            utils.setStatusError(node, "file error");
                             node.error("Failed to save message: " + err.message);
                         }
                     } else {
                         // Store in memory and context
-                        node.runtime.storedMsg = { [node.runtime.transferProperty]: value };
-                        node.context().set("storedMsg", node.runtime.storedMsg);
-                        lastUpdateMsg = node.runtime.storedMsg;
+                        node.storedMsg = { [node.transferProperty]: value };
+                        node.context().set("storedMsg", node.storedMsg);
+                        lastUpdateMsg = node.storedMsg;
                         if (writeTimeout) clearTimeout(writeTimeout);
                         writeTimeout = setTimeout(() => {
                             saveMessage();
                         }, writePeriod);
                     }
                     const outMsg = RED.util.cloneMessage(msg);
-                    outMsg[node.runtime.transferProperty] = value;
-                    const payloadStr = msg[node.runtime.transferProperty] != null ? String(msg[node.runtime.transferProperty]).substring(0, 20) : "null";
-                    node.status({ fill: "blue", shape: "dot", text: `in: executeWithFallback, out2: ${payloadStr}` });
+                    outMsg[node.transferProperty] = value;
+                    const payloadStr = msg[node.transferProperty] != null ? String(msg[node.transferProperty]).substring(0, 20) : "null";
+                    utils.setStatusChanged(node, `in: executeWithFallback, out2: ${payloadStr}`);
                     output[1] = outMsg;
                 }
                 send(output);
@@ -209,29 +208,29 @@ module.exports = function(RED) {
             }
 
             if (msg.context === "query") {
-                const hasValue = node.runtime.writeOnUpdate ? fsSync.existsSync(filePath) : node.runtime.storedMsg !== null;
-                node.status({ fill: "blue", shape: "dot", text: `in: query, out1: ${hasValue}` });
+                const hasValue = node.writeOnUpdate ? fsSync.existsSync(filePath) : node.storedMsg !== null;
+                utils.setStatusChanged(node, `in: query, out1: ${hasValue}`);
                 output[0] = { payload: hasValue };
                 send(output);
                 if (done) done();
                 return;
             }
 
-            node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+            utils.setStatusWarn(node, "unknown context");
             if (done) done("Unknown context");
         });
 
         node.on("close", function(done) {
             if (writeTimeout) clearTimeout(writeTimeout);
-            if (!node.runtime.writeOnUpdate && lastUpdateMsg) {
+            if (!node.writeOnUpdate && lastUpdateMsg) {
                 saveMessage()
                     .then(() => {
-                        node.status({});
+                        utils.setStatusOK(node, "");
                         done();
                     })
                     .catch(err => {
                         node.error("Failed to save message on close: " + err.message);
-                        node.status({});
+                        utils.setStatusError(node, "save error");
                         done();
                     });
             } else {

package/nodes/min-block.js

@@ -7,10 +7,9 @@ module.exports = function(RED) {
         node.isBusy = false;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            min: parseFloat(config.min)
-        };
+        // Initialize state
+        node.name = config.name;
+        node.min = parseFloat(config.min);
 
         // Store last output value for status
         let lastOutput = null;
@@ -20,7 +19,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;
             }
@@ -31,7 +30,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;
                 }
@@ -46,13 +45,13 @@ module.exports = function(RED) {
                     utils.requiresEvaluation(config.minType) 
                         ? utils.evaluateNodeProperty(config.min, config.minType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.min),
+                        : Promise.resolve(node.min),
                 );
 
                 const results = await Promise.all(evaluations);   
 
                 // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.runtime.min = results[0];       
+                if (!isNaN(results[0])) node.min = results[0];       
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -63,8 +62,8 @@ module.exports = function(RED) {
             }
 
             // Validate
-            if (isNaN(node.runtime.min)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid evaluated values" });
+            if (isNaN(node.min)) {
+                utils.setStatusError(node, "invalid evaluated values");
                 if (done) done();
                 return;
             }
@@ -72,22 +71,22 @@ module.exports = function(RED) {
             // Handle context updates
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload for min" });
+                    utils.setStatusError(node, "missing payload for min");
                     if (done) done();
                     return;
                 }
                 if (msg.context === "min" || msg.context === "setpoint") {
                     const minValue = parseFloat(msg.payload);
                     if (!isNaN(minValue) && minValue >= 0) {
-                        node.runtime.min = minValue;
-                        node.status({ fill: "green", shape: "dot", text: `min: ${minValue}` });
+                        node.min = minValue;
+                        utils.setStatusOK(node, `min: ${minValue}`);
                     } else {
-                        node.status({ fill: "red", shape: "ring", text: "invalid min" });
+                        utils.setStatusError(node, "invalid min");
                     }
                     if (done) done();
                     return;
                 } else {
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done();
                     return;
                 }
@@ -95,28 +94,30 @@ module.exports = function(RED) {
 
             // Validate input payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
-            const inputValue = parseFloat(msg.payload);
-            if (isNaN(inputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+            const numVal = utils.validateNumericPayload(msg.payload);
+            if (!numVal.valid) {
+                utils.setStatusError(node, numVal.error);
                 if (done) done();
                 return;
             }
+            const inputValue = numVal.value;
 
             // Cap input at min
-            const outputValue = Math.max(inputValue, node.runtime.min);
+            const outputValue = Math.max(inputValue, node.min);
 
             // Update status and send output
             msg.payload = outputValue;
-            node.status({
-                fill: "blue",
-                shape: lastOutput === outputValue ? "ring" : "dot",
-                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
-            });
+            const statusText = `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`;
+            if (lastOutput === outputValue) {
+                utils.setStatusUnchanged(node, statusText);
+            } else {
+                utils.setStatusChanged(node, statusText);
+            }
             lastOutput = outputValue;
             send(msg);
 

package/nodes/minmax-block.js

@@ -7,11 +7,10 @@ module.exports = function(RED) {
         node.isBusy = false;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            min: parseFloat(config.min),
-            max: parseFloat(config.max)
-        };
+        // Initialize state
+        node.name = config.name;
+        node.min = parseFloat(config.min);
+        node.max = parseFloat(config.max);
 
         // Store last output value for status
         let lastOutput = null;
@@ -21,7 +20,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,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.minType) 
                         ? utils.evaluateNodeProperty(config.min, config.minType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.min),
+                        : Promise.resolve(node.min),
                 );
 
                 evaluations.push(
                     utils.requiresEvaluation(config.maxType) 
                         ? utils.evaluateNodeProperty(config.max, config.maxType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.max),
+                        : Promise.resolve(node.max),
                 );
 
                 const results = await Promise.all(evaluations);   
 
                 // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.runtime.min = results[0];
-                if (!isNaN(results[1])) node.runtime.max = results[1];
+                if (!isNaN(results[0])) node.min = results[0];
+                if (!isNaN(results[1])) node.max = results[1];
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -72,8 +71,8 @@ module.exports = function(RED) {
             }
 
             // Validate min and max
-            if (isNaN(node.runtime.min) || isNaN(node.runtime.max) || node.runtime.min > node.runtime.max) {
-                node.status({ fill: "red", shape: "dot", text: `invalid min/max` });
+            if (isNaN(node.min) || isNaN(node.max) || node.min > node.max) {
+                utils.setStatusError(node, `invalid min/max`);
                 if (done) done();
                 return;
             }
@@ -81,32 +80,32 @@ module.exports = function(RED) {
             // Handle context updates
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    utils.setStatusError(node, `missing payload for ${msg.context}`);
                     if (done) done();
                     return;
                 }
                 const value = parseFloat(msg.payload);
                 if (isNaN(value) || value < 0) {
-                    node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                    utils.setStatusError(node, `invalid ${msg.context}`);
                     if (done) done();
                     return;
                 }
                 if (msg.context === "min") {
-                    if (value < node.runtime.max) {
-                        node.runtime.min = value;
-                        node.status({ fill: "green", shape: "dot", text: `min: ${node.runtime.min}` });
+                    if (value < node.max) {
+                        node.min = value;
+                        utils.setStatusOK(node, `min: ${node.min}`);
                     } else {
-                        node.status({ fill: "yellow", shape: "dot", text: `Context update aborted. Payload more than max` });
+                        utils.setStatusWarn(node, `Context update aborted. Payload more than max`);
                     }
                 } else if (msg.context === "max") {
-                    if (value > node.runtime.min) {
-                        node.runtime.max = value;
-                        node.status({ fill: "green", shape: "dot", text: `max: ${node.runtime.max}` });
+                    if (value > node.min) {
+                        node.max = value;
+                        utils.setStatusOK(node, `max: ${node.max}`);
                     } else {
-                        node.status({ fill: "yellow", shape: "dot", text: `Context update aborted. Payload less than min` });
+                        utils.setStatusWarn(node, `Context update aborted. Payload less than min`);
                     }
                 } else {
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done();
                     return;
                 }
@@ -116,28 +115,30 @@ module.exports = function(RED) {
 
             // Validate input payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
-            const inputValue = parseFloat(msg.payload);
-            if (isNaN(inputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+            const numVal = utils.validateNumericPayload(msg.payload);
+            if (!numVal.valid) {
+                utils.setStatusError(node, numVal.error);
                 if (done) done();
                 return;
             }
+            const inputValue = numVal.value;
 
             // Clamp input to [min, max]
-            const outputValue = Math.min(Math.max(inputValue, node.runtime.min), node.runtime.max);
+            const outputValue = Math.min(Math.max(inputValue, node.min), node.max);
 
             // Update status and send output
             msg.payload = outputValue;
-            node.status({
-                fill: "blue",
-                shape: lastOutput === outputValue ? "ring" : "dot",
-                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
-            });
+            const statusText = `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`;
+            if (lastOutput === outputValue) {
+                utils.setStatusUnchanged(node, statusText);
+            } else {
+                utils.setStatusChanged(node, statusText);
+            }
             lastOutput = outputValue;
             send(msg);