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

package/nodes/priority-block.js

@@ -1,13 +1,14 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function PriorityBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
         const context = this.context();
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name
-        };
+        // Initialize state
+        node.name = config.name;
 
         // Initialize state from context or defaults
         let priorities = context.get("priorities") || {
@@ -37,14 +38,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;
             }
 
             // Validate payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
@@ -72,7 +73,7 @@ module.exports = function(RED) {
                     context.set("defaultValue", defaultValue);
                     context.set("fallbackValue", fallbackValue);
                     context.set("messages", messages);
-                    node.status({ fill: "green", shape: "dot", text: "all slots cleared" });
+                    utils.setStatusOK(node, "all slots cleared");
                 } else if (typeof clear === "string" && isValidSlot(clear)) {
                     if (clear.startsWith("priority")) priorities[clear] = null;
                     else if (clear === "default") defaultValue = null;
@@ -82,7 +83,7 @@ module.exports = function(RED) {
                     context.set("defaultValue", defaultValue);
                     context.set("fallbackValue", fallbackValue);
                     context.set("messages", messages);
-                    node.status({ fill: "green", shape: "dot", text: `${clear} cleared` });
+                    utils.setStatusOK(node, `${clear} cleared`);
                 } else if (Array.isArray(clear) && clear.every(isValidSlot)) {
                     clear.forEach(slot => {
                         if (slot.startsWith("priority")) priorities[slot] = null;
@@ -94,16 +95,16 @@ module.exports = function(RED) {
                     context.set("defaultValue", defaultValue);
                     context.set("fallbackValue", fallbackValue);
                     context.set("messages", messages);
-                    node.status({ fill: "green", shape: "dot", text: `${clear.join(", ")} cleared` });
+                    utils.setStatusOK(node, `${clear.join(", ")} cleared`);
                 } else {
-                    node.status({ fill: "red", shape: "ring", text: "invalid clear" });
+                    utils.setStatusError(node, "invalid clear");
                     if (done) done();
                     return;
                 }
             } else if (msg.payload === "clear") {
                 // Handle string "clear" with msg.context
                 if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
-                    node.status({ fill: "red", shape: "ring", text: "missing or invalid context for clear" });
+                    utils.setStatusError(node, "missing or invalid context for clear");
                     if (done) done();
                     return;
                 }
@@ -117,16 +118,16 @@ module.exports = function(RED) {
                     context.set("defaultValue", defaultValue);
                     context.set("fallbackValue", fallbackValue);
                     context.set("messages", messages);
-                    node.status({ fill: "green", shape: "dot", text: `${contextMsg} cleared` });
+                    utils.setStatusOK(node, `${contextMsg} cleared`);
                 } else {
-                    node.status({ fill: "red", shape: "ring", text: "invalid clear context" });
+                    utils.setStatusError(node, "invalid clear context");
                     if (done) done();
                     return;
                 }
             } else {
                 // Handle non-object, non-"clear" payloads
                 if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
-                    node.status({ fill: "red", shape: "ring", text: "missing or invalid context" });
+                    utils.setStatusError(node, "missing or invalid context");
                     if (done) done();
                     return;
                 }
@@ -135,7 +136,7 @@ module.exports = function(RED) {
                 const value = msg.payload === null ? null : typeof msg.payload === "number" ? parseFloat(msg.payload) : typeof msg.payload === "boolean" ? msg.payload : null;
 
                 if (value === null && msg.payload !== null) {
-                    node.status({ fill: "red", shape: "ring", text: `invalid ${contextMsg}` });
+                    utils.setStatusError(node, `invalid ${contextMsg}`);
                     if (done) done();
                     return;
                 }
@@ -145,33 +146,24 @@ module.exports = function(RED) {
                     messages[contextMsg] = RED.util.cloneMessage(msg);
                     context.set("priorities", priorities);
                     context.set("messages", messages);
-                    node.status({
-                        fill: "green",
-                        shape: "dot",
-                        text: value === null ? `${contextMsg} relinquished` : `${contextMsg}: ${typeof value === "number" ? value.toFixed(2) : value}`
-                    });
+                    const priorityText = value === null ? `${contextMsg} relinquished` : `${contextMsg}: ${typeof value === "number" ? value.toFixed(2) : value}`;
+                    utils.setStatusOK(node, priorityText);
                 } else if (contextMsg === "default") {
                     defaultValue = value;
                     messages[contextMsg] = RED.util.cloneMessage(msg);
                     context.set("defaultValue", defaultValue);
                     context.set("messages", messages);
-                    node.status({
-                        fill: "green",
-                        shape: "dot",
-                        text: value === null ? "default relinquished" : `default: ${typeof value === "number" ? value.toFixed(2) : value}`
-                    });
+                    const defaultText = value === null ? "default relinquished" : `default: ${typeof value === "number" ? value.toFixed(2) : value}`;
+                    utils.setStatusOK(node, defaultText);
                 } else if (contextMsg === "fallback") {
                     fallbackValue = value;
                     messages[contextMsg] = RED.util.cloneMessage(msg);
                     context.set("fallbackValue", fallbackValue);
                     context.set("messages", messages);
-                    node.status({
-                        fill: "green",
-                        shape: "dot",
-                        text: value === null ? "fallback relinquished" : `fallback: ${typeof value === "number" ? value.toFixed(2) : value}`
-                    });
+                    const fallbackText = value === null ? "fallback relinquished" : `fallback: ${typeof value === "number" ? value.toFixed(2) : value}`;
+                    utils.setStatusOK(node, fallbackText);
                 } else {
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done("Unknown context");
                     return;
                 }
@@ -182,11 +174,8 @@ module.exports = function(RED) {
             send(currentOutput);
             const inDisplay = typeof msg.payload === "number" ? msg.payload.toFixed(2) : typeof msg.payload === "object" ? JSON.stringify(msg.payload).slice(0, 20) : msg.payload;
             const outDisplay = currentOutput.payload === null ? "null" : typeof currentOutput.payload === "number" ? currentOutput.payload.toFixed(2) : currentOutput.payload;
-            node.status({
-                fill: "blue",
-                shape: "dot",
-                text: `in: ${inDisplay}, out: ${outDisplay}, slot: ${currentOutput.diagnostics.activePriority || "none"}`
-            });
+            const statusText = `in: ${inDisplay}, out: ${outDisplay}, slot: ${currentOutput.diagnostics.activePriority || "none"}`;
+            utils.setStatusChanged(node, statusText);
 
             if (done) done();
 

package/nodes/rate-limit-block.js

@@ -1,64 +1,64 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function RateLimitBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            mode: config.mode,
-            rate: parseFloat(config.rate),
-            interval: parseInt(config.interval),
-            threshold: parseFloat(config.threshold),
-            currentValue: 0,
-            targetValue: 0,
-            lastUpdate: Date.now(),
-            lastInputMsg: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.mode = config.mode;
+        node.rate = parseFloat(config.rate);
+        node.interval = parseInt(config.interval);
+        node.threshold = parseFloat(config.threshold);
+        node.currentValue = 0;
+        node.targetValue = 0;
+        node.lastUpdate = Date.now();
+        node.lastInputMsg = null;
 
         // Validate initial config
-        if (isNaN(node.runtime.rate) || node.runtime.rate <= 0 || !isFinite(node.runtime.rate)) {
-            node.runtime.rate = 1.0;
-            node.status({ fill: "red", shape: "ring", text: "invalid rate" });
+        if (isNaN(node.rate) || node.rate <= 0 || !isFinite(node.rate)) {
+            node.rate = 1.0;
+            utils.setStatusError(node, "invalid rate");
         }
-        if (isNaN(node.runtime.interval) || node.runtime.interval < 10 || !Number.isInteger(node.runtime.interval)) {
-            node.runtime.interval = 100;
-            node.status({ fill: "red", shape: "ring", text: "invalid interval" });
+        if (isNaN(node.interval) || node.interval < 10 || !Number.isInteger(node.interval)) {
+            node.interval = 100;
+            utils.setStatusError(node, "invalid interval");
         }
-        if (isNaN(node.runtime.threshold) || node.runtime.threshold < 0 || !isFinite(node.runtime.threshold)) {
-            node.runtime.threshold = 5.0;
-            node.status({ fill: "red", shape: "ring", text: "invalid threshold" });
+        if (isNaN(node.threshold) || node.threshold < 0 || !isFinite(node.threshold)) {
+            node.threshold = 5.0;
+            utils.setStatusError(node, "invalid threshold");
         }
-        if (!["rate-limit", "threshold", "full-value"].includes(node.runtime.mode)) {
-            node.runtime.mode = "rate-limit";
-            node.status({ fill: "red", shape: "ring", text: "invalid mode" });
+        if (!["rate-limit", "threshold", "full-value"].includes(node.mode)) {
+            node.mode = "rate-limit";
+            utils.setStatusError(node, "invalid mode");
         }
 
         // Set initial status
-        node.status({ fill: "blue", shape: "dot", text: `mode: ${node.runtime.mode}, out: ${node.runtime.currentValue.toFixed(2)}` });
+        utils.setStatusOK(node, `mode: ${node.mode}, out: ${node.currentValue.toFixed(2)}`);
 
         let updateTimer = null;
 
         // Function to update output for rate-limit mode
         function updateRateLimitOutput() {
-            if (!node.runtime.lastInputMsg) return;
+            if (!node.lastInputMsg) return;
             const now = Date.now();
-            const elapsed = (now - node.runtime.lastUpdate) / 1000; // Seconds
-            const maxChange = node.runtime.rate * elapsed;
-            let newValue = node.runtime.currentValue;
-
-            if (node.runtime.currentValue < node.runtime.targetValue) {
-                newValue = Math.min(node.runtime.currentValue + maxChange, node.runtime.targetValue);
-            } else if (node.runtime.currentValue > node.runtime.targetValue) {
-                newValue = Math.max(node.runtime.currentValue - maxChange, node.runtime.targetValue);
+            const elapsed = (now - node.lastUpdate) / 1000; // Seconds
+            const maxChange = node.rate * elapsed;
+            let newValue = node.currentValue;
+
+            if (node.currentValue < node.targetValue) {
+                newValue = Math.min(node.currentValue + maxChange, node.targetValue);
+            } else if (node.currentValue > node.targetValue) {
+                newValue = Math.max(node.currentValue - maxChange, node.targetValue);
             }
 
-            if (newValue !== node.runtime.currentValue) {
-                node.runtime.currentValue = newValue;
-                node.runtime.lastUpdate = now;
-                const msg = RED.util.cloneMessage(node.runtime.lastInputMsg);
-                msg.payload = node.runtime.currentValue;
-                node.status({ fill: "blue", shape: "dot", text: `mode: rate-limit, out: ${node.runtime.currentValue.toFixed(2)}` });
+            if (newValue !== node.currentValue) {
+                node.currentValue = newValue;
+                node.lastUpdate = now;
+                const msg = RED.util.cloneMessage(node.lastInputMsg);
+                msg.payload = node.currentValue;
+                utils.setStatusOK(node, `mode: rate-limit, out: ${node.currentValue.toFixed(2)}`);
                 node.send(msg);
             }
         }
@@ -66,8 +66,8 @@ module.exports = function(RED) {
         // Start update timer for rate-limit mode
         function startTimer() {
             if (updateTimer) clearInterval(updateTimer);
-            if (node.runtime.mode === "rate-limit") {
-                updateTimer = setInterval(updateRateLimitOutput, node.runtime.interval);
+            if (node.mode === "rate-limit") {
+                updateTimer = setInterval(updateRateLimitOutput, node.interval);
             }
         }
 
@@ -76,7 +76,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;
             }
@@ -84,54 +84,54 @@ 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;
                 }
                 switch (msg.context) {
                     case "mode":
                         if (!["rate-limit", "threshold", "full-value"].includes(msg.payload)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid mode" });
+                            utils.setStatusError(node, "invalid mode");
                             if (done) done();
                             return;
                         }
-                        node.runtime.mode = msg.payload;
+                        node.mode = msg.payload;
                         startTimer();
-                        node.status({ fill: "green", shape: "dot", text: `mode: ${node.runtime.mode}` });
+                        utils.setStatusOK(node, `mode: ${node.mode}`);
                         break;
                     case "rate":
                         const rate = parseFloat(msg.payload);
                         if (isNaN(rate) || rate <= 0 || !isFinite(rate)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid rate" });
+                            utils.setStatusError(node, "invalid rate");
                             if (done) done();
                             return;
                         }
-                        node.runtime.rate = rate;
-                        node.status({ fill: "green", shape: "dot", text: `rate: ${node.runtime.rate.toFixed(2)}` });
+                        node.rate = rate;
+                        utils.setStatusOK(node, `rate: ${node.rate.toFixed(2)}`);
                         break;
                     case "interval":
                         const interval = parseInt(msg.payload);
                         if (isNaN(interval) || interval < 10 || !Number.isInteger(interval)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid interval" });
+                            utils.setStatusError(node, "invalid interval");
                             if (done) done();
                             return;
                         }
-                        node.runtime.interval = interval;
+                        node.interval = interval;
                         startTimer();
-                        node.status({ fill: "green", shape: "dot", text: `interval: ${node.runtime.interval}` });
+                        utils.setStatusOK(node, `interval: ${node.interval}`);
                         break;
                     case "threshold":
                         const threshold = parseFloat(msg.payload);
                         if (isNaN(threshold) || threshold < 0 || !isFinite(threshold)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid threshold" });
+                            utils.setStatusError(node, "invalid threshold");
                             if (done) done();
                             return;
                         }
-                        node.runtime.threshold = threshold;
-                        node.status({ fill: "green", shape: "dot", text: `threshold: ${node.runtime.threshold.toFixed(2)}` });
+                        node.threshold = threshold;
+                        utils.setStatusOK(node, `threshold: ${node.threshold.toFixed(2)}`);
                         break;
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         if (done) done("Unknown context");
                         return;
                 }
@@ -141,35 +141,33 @@ module.exports = function(RED) {
 
             // Validate input
             if (typeof msg.payload !== "number" || isNaN(msg.payload) || !isFinite(msg.payload)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                utils.setStatusError(node, "invalid input");
                 if (done) done();
                 return;
             }
 
             const inputValue = msg.payload;
-            node.runtime.lastInputMsg = RED.util.cloneMessage(msg);
+            node.lastInputMsg = RED.util.cloneMessage(msg);
 
-            if (node.runtime.mode === "rate-limit") {
-                node.runtime.targetValue = inputValue;
-                node.status({ fill: "green", shape: "dot", text: `mode: rate-limit, target: ${node.runtime.targetValue.toFixed(2)}` });
+            if (node.mode === "rate-limit") {
+                node.targetValue = inputValue;
+                utils.setStatusOK(node, `mode: rate-limit, target: ${node.targetValue.toFixed(2)}`);
                 updateRateLimitOutput();
                 startTimer();
-            } else if (node.runtime.mode === "threshold") {
-                const diff = Math.abs(inputValue - node.runtime.currentValue);
-                if (diff > node.runtime.threshold) {
+            } else if (node.mode === "threshold") {
+                const diff = Math.abs(inputValue - node.currentValue);
+                if (diff > node.threshold) {
                     msg.payload = inputValue;
-                    node.runtime.currentValue = inputValue;
-                    node.status({ fill: "blue", shape: "dot", text: `mode: threshold, out: ${node.runtime.currentValue.toFixed(2)}` });
+                    node.currentValue = inputValue;
+                    utils.setStatusChanged(node, `mode: threshold, out: ${node.currentValue.toFixed(2)}`);
                     send(msg);
                 } else {
-                    node.status({ fill: "blue", shape: "ring", text: `mode: threshold, out: ${node.runtime.currentValue.toFixed(2)}`
-                    });
+                    utils.setStatusUnchanged(node, `mode: threshold, out: ${node.currentValue.toFixed(2)}`);
                 }
-            } else if (node.runtime.mode === "full-value") {
-                node.runtime.currentValue = inputValue;
+            } else if (node.mode === "full-value") {
+                node.currentValue = inputValue;
                 msg.payload = inputValue;
-                node.status({ fill: "blue", shape: "dot", text: `mode: full-value, out: ${node.runtime.currentValue.toFixed(2)}`
-                });
+                utils.setStatusChanged(node, `mode: full-value, out: ${node.currentValue.toFixed(2)}`);
                 send(msg);
             }
 

package/nodes/rate-of-change-block.html

@@ -3,6 +3,10 @@
         <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">
+        <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-sampleSize" title="Number of samples to track (minimum 2)"><i class="fa fa-list-ol"></i> Sample Size</label>
         <input type="number" id="node-input-sampleSize" placeholder="10" min="2" step="1">
@@ -33,6 +37,7 @@
         color: "#301934",
         defaults: {
             name: { value: "" },
+            inputProperty: { value: "payload" },
             sampleSize: {
                 value: 10,
                 required: true,
@@ -80,31 +85,45 @@
 </script>
 
 <script type="text/markdown" data-help-name="rate-of-change-block">
-Calculates the rate of temperature change over time for HVAC applications.
+Calculates the rate of value change over time.
 
 ### Inputs
+: input-property (number) : Numeric value to track for rate calculation, read from the configured Input Property.
 : context (string) : Configures reset (`"reset"`), sample size (`"sampleSize"`), or units (`"units"`).
-: payload (number) : Temperature value for rate calculation.
-: timestamp (optional) : Custom timestamp for the reading.
+: payload (number | boolean | string) : Value for configuration (numeric for rate, boolean for reset, string for units).
+: timestamp (optional) : Custom timestamp for the reading (ms since epoch).
 
 ### Outputs
-: payload (number | null) : Rate of change in temperature per time unit.
+: payload (number | null) : Rate of change in value per time unit.
 : samples (number) : Current number of samples in buffer.
-: units (string) : Rate units ("°/s", "°/min", "°/hr").
-: currentValue (number) : Most recent temperature value.
+: units (string) : Rate units ("per second", "per minute", "per hour").
+: currentValue (number) : Most recent value.
 : timeSpan (number) : Time span of sample buffer in seconds.
 
+### Properties
+: name (string) : Display name in editor.
+: inputProperty (string) : Message property to read values from (default: `payload`). Supports nested properties (e.g., `data.value`).
+: sampleSize (number) : Number of samples to maintain (≥ 2).
+: rateUnits (string) : Units for rate output (`"seconds"`, `"minutes"`, `"hours"`).
+
 ### Details
-Tracks temperature changes over a rolling window of samples. Calculates rate as (last_value - first_value) / time_difference.
+Tracks value changes over a rolling window of samples. Calculates rate as `(last_value - first_value) / time_difference`.
 
-Useful for detecting HVAC issues like temperature droop, defrost cycles, or rapid changes.
+Useful for detecting system issues like rapid changes, droop, or anomalies.
 
-### Configuration
-- Reset via `msg.context = "reset"` with `msg.payload = true`
-- Change sample size via `msg.context = "sampleSize"` with numeric payload
-- Change units via `msg.context = "units"` with "seconds", "minutes", or "hours"
+Configuration via `msg.context`:
+- `"reset"`: Clears sample buffer (no output).
+- `"sampleSize"`: Changes number of samples with numeric `msg.payload`.
+- `"units"`: Changes rate units with `msg.payload` as `"seconds"`, `"minutes"`, or `"hours"`.
 
 ### Status
-- Shows current rate with units
-- Color indicates state change
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
 </script>