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

package/nodes/interpolate-block.js

@@ -1,34 +1,31 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function InterpolateBlockNode(config) {
         RED.nodes.createNode(this, config);
         
         const node = this;
         
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            points: null,
-            lastOutput: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.inputProperty = config.inputProperty || "payload";
+        node.points = null;
+        node.lastOutput = null;
 
         // Initialize points
         try {
-            node.runtime.points = config.points ? JSON.parse(config.points) : [{ x: 0, y: 0 }, { x: 100, y: 100 }];
-            if (!Array.isArray(node.runtime.points) || node.runtime.points.length < 2 ||
-                !node.runtime.points.every(p => typeof p.x === "number" && !isNaN(p.x) &&
+            node.points = config.points ? JSON.parse(config.points) : [{ x: 0, y: 0 }, { x: 100, y: 100 }];
+            if (!Array.isArray(node.points) || node.points.length < 2 ||
+                !node.points.every(p => typeof p.x === "number" && !isNaN(p.x) &&
                                                 typeof p.y === "number" && !isNaN(p.y))) {
-                node.runtime.points = [{ x: 0, y: 0 }, { x: 100, y: 100 }];
-                node.status({ fill: "red", shape: "ring", text: "invalid points, using default" });
+                node.points = [{ x: 0, y: 0 }, { x: 100, y: 100 }];
+                utils.setStatusError(node, "invalid points, using default");
             } else {
-                node.status({
-                    fill: "green",
-                    shape: "dot",
-                    text: `name: ${node.runtime.name}, points: ${node.runtime.points.length}`
-                });
+                utils.setStatusOK(node, `name: ${node.name}, points: ${node.points.length}`);
             }
         } catch (e) {
-            node.runtime.points = [{ x: 0, y: 0 }, { x: 100, y: 100 }];
-            node.status({ fill: "red", shape: "ring", text: "invalid points, using default" });
+            node.points = [{ x: 0, y: 0 }, { x: 100, y: 100 }];
+            utils.setStatusError(node, "invalid points, using default");
         }
 
         node.on("input", function(msg, send, done) {
@@ -36,7 +33,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;
             }
@@ -44,12 +41,12 @@ module.exports = function(RED) {
             // Handle configuration messages
             if (msg.context) {
                 if (typeof msg.context !== "string" || !msg.context.trim()) {
-                    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;
                 }
@@ -59,49 +56,43 @@ module.exports = function(RED) {
                         if (Array.isArray(newPoints) && newPoints.length >= 2 &&
                             newPoints.every(p => typeof p.x === "number" && !isNaN(p.x) &&
                                                 typeof p.y === "number" && !isNaN(p.y))) {
-                            node.runtime.points = newPoints;
-                            node.status({
-                                fill: "green",
-                                shape: "dot",
-                                text: `points: ${newPoints.length}`
-                            });
+                            node.points = newPoints;
+                            utils.setStatusOK(node, `points: ${newPoints.length}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid points" });
+                            utils.setStatusError(node, "invalid points");
                         }
                     } catch (e) {
-                        node.status({ fill: "red", shape: "ring", text: "invalid points" });
+                        utils.setStatusError(node, "invalid points");
                     }
                     if (done) done();
                     return;
                 } else {
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done();
                     return;
                 }
             }
 
-            // Check for missing payload
-            if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
-                if (done) done();
-                return;
+            // Check for missing input property
+            let inputValue;
+            try {
+                inputValue = parseFloat(RED.util.getMessageProperty(msg, node.inputProperty));
+            } catch (err) {
+                inputValue = NaN;
             }
-
-            // Process input
-            const inputValue = parseFloat(msg.payload);
             if (isNaN(inputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                utils.setStatusError(node, "missing or invalid input property");
                 if (done) done();
                 return;
             }
 
             // Linear interpolation
             let outputValue = NaN;
-            const isPositiveSlope = node.runtime.points.length >= 2 && node.runtime.points[1].x > node.runtime.points[0].x;
+            const isPositiveSlope = node.points.length >= 2 && node.points[1].x > node.points[0].x;
 
-            for (let i = 0; i < node.runtime.points.length - 1; i++) {
-                let x1 = node.runtime.points[i].x, y1 = node.runtime.points[i].y;
-                let x2 = node.runtime.points[i + 1].x, y2 = node.runtime.points[i + 1].y;
+            for (let i = 0; i < node.points.length - 1; i++) {
+                let x1 = node.points[i].x, y1 = node.points[i].y;
+                let x2 = node.points[i + 1].x, y2 = node.points[i + 1].y;
                 if (isPositiveSlope ? (inputValue >= x1 && inputValue <= x2) : (inputValue <= x1 && inputValue >= x2)) {
                     let m = (y2 - y1) / (x2 - x1);
                     let b = y1 - (m * x1);
@@ -111,21 +102,19 @@ module.exports = function(RED) {
             }
 
             if (isNaN(outputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "input out of range" });
+                utils.setStatusError(node, "input out of range");
                 if (done) done();
                 return;
             }
 
             // Check if output value has changed
-            const isUnchanged = outputValue === node.runtime.lastOutput;
-            node.status({
-                fill: "blue",
-                shape: isUnchanged ? "ring" : "dot",
-                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
-            });
+            const isUnchanged = outputValue === node.lastOutput;
+            const statusShape = isUnchanged ? "ring" : "dot";
+            utils.setStatusOK(node, `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`);
+            if (statusShape === "ring") utils.setStatusUnchanged(node, `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`);
 
             if (!isUnchanged) {
-                node.runtime.lastOutput = outputValue;
+                node.lastOutput = outputValue;
                 send({ payload: outputValue });
             }
 

package/nodes/join.html

@@ -0,0 +1,78 @@
+<!-- Data Template -->
+<script type="text/html" data-template-name="bldgblocks-join">
+    <div class="form-row">
+        <label for="node-input-name"><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-count"><i class="fa fa-sort-numeric-asc"></i> Key Count</label>
+        <input type="number" id="node-input-count" placeholder="4">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-excludedKeys"><i class="fa fa-ban"></i> Exclude</label>
+        <input type="text" id="node-input-excludedKeys" placeholder="status, req, res">
+        <div style="font-size: 0.8em; color: #888; margin-left: 105px;">Comma separated list of properties to ignore</div>
+    </div>
+
+    <div class="form-tips">
+        <b>Note:</b> Works with root properties only and must all be unique. Nested properties are not supported.
+        Instead of incoming properties like 'outdoor.temp' (a nested object), consider using outdoor/temp or outdoorTemp as property names.
+    </div>
+</script>
+
+<!-- Registration & logic -->
+<script type="text/javascript">
+    RED.nodes.registerType('bldgblocks-join', {
+        category: "bldgblocks control",
+        color: '#301934',
+        defaults: {
+            name: { value: "" },
+            count: { value: 4, required: true, validate: RED.validators.number() },
+            excludedKeys: { value: "status" } // Default to 'status' to maintain previous behavior
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-compress",
+        label: function() {
+            return this.name || "join (" + this.count + ")";
+        },
+        paletteLabel: "join",
+        oneditprepare: function() {
+            // Optional: visual tweaks when opening the edit dialog
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="bldgblocks-join">
+Joins multiple messages into a single message by accumulating unique properties. 
+This differs from the standard Node-RED Join node by focusing on unique keys rather than message counts or parts
+and combines to root level using property names.
+
+### Inputs 
+: all (any) : All unique properties from incoming messages.
+: Key Count (number) : The number of unique keys required before the node emits the accumulated message.
+: Exclude (string) : A comma-separated list of properties to ignore (e.g., `status, topic`).
+
+### Outputs
+: msg (any) : All unique properties combined at root level into a single message.
+
+### Details
+1. The node stores a running list of properties from every `msg` it receives.
+2. It ignores properties starting with `_` (like `_msgid`).
+3. It ignores any properties listed in the `Exclude` configuration.
+4. When the number of stored unique keys equals or exceeds the `Key Count`, it emits the combined object as a new message.
+
+### Status
+- 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>

package/nodes/join.js

@@ -0,0 +1,78 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+    function BldgBlocksJoinNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Get configuration from the UI
+        node.targetCount = parseInt(config.count) || 4;
+        
+        // Parse excluded keys string into a Set for fast lookup
+        // Split by comma, trim whitespace, and remove empty entries
+        const exclusionString = config.excludedKeys || "";
+        const excludedSet = new Set(
+            exclusionString.split(',').map(s => s.trim()).filter(s => s.length > 0)
+        );
+
+        // --- INPUT HANDLER ---
+        node.on('input', function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Get current state from context
+            let valueMap = node.context().get("valueMap") || {};
+            
+            // Add properties from incoming message to the state
+            Object.keys(msg).forEach(key => {
+                // Logic:
+                // 1. Value must exist (not undefined/null)
+                // 2. Key must NOT start with '_' (internal Node-RED props)
+                // 3. Key must NOT be in the user-defined excluded list
+                if (
+                    msg[key] !== undefined &&  
+                    !key.startsWith('_') && 
+                    !excludedSet.has(key)
+                ) {
+                    valueMap[key] = msg[key];
+                }
+            });
+
+            // Calculate current unique key count
+            const currentCount = Object.keys(valueMap).length;
+
+            // Update status
+            if (currentCount >= node.targetCount) {
+                utils.setStatusOK(node, `${currentCount}/${node.targetCount} keys`);
+            } else {
+                utils.setStatusChanged(node, `${currentCount}/${node.targetCount} keys`);
+            }
+
+            // Save state back to context
+            node.context().set("valueMap", valueMap);
+
+            // Check if we hit the target
+            if (currentCount >= node.targetCount) {
+                // Clone the map to create the output message
+                const outputMsg = RED.util.cloneMessage(valueMap);
+                
+                // Ensure we have a msgid
+                if (!outputMsg._msgid) {
+                    outputMsg._msgid = RED.util.generateId();
+                }
+
+                send(outputMsg);
+            }
+
+            if (done) {
+                done();
+            }
+        });
+
+        node.on('close', function(removed, done) {
+            if (removed) {
+                node.context().set("valueMap", undefined);
+            }
+            done();
+        });
+    }
+    RED.nodes.registerType("bldgblocks-join", BldgBlocksJoinNode);
+}

package/nodes/latch-block.js

@@ -1,4 +1,6 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function LatchBlockNode(config) {
         RED.nodes.createNode(this, config);
 
@@ -8,25 +10,21 @@ module.exports = function(RED) {
         node.state = config.state;
 
         // Set initial status
-        node.status({
-            fill: "green",
-            shape: "dot",
-            text: `state: ${node.state}`
-        });
+        utils.setStatusOK(node, `state: ${node.state}`);
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             // 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 context
             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;
             }
@@ -35,13 +33,13 @@ module.exports = function(RED) {
             switch (msg.context) {
                 case "set":
                     if (node.state) {
-                        node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                        utils.setStatusUnchanged(node, `state: ${node.state}`);
                     } else {
                         if (msg.payload) {
                             node.state = true;
-                            node.status({ fill: "blue", shape: "dot", text: `state: ${node.state}` });
+                            utils.setStatusChanged(node, `state: ${node.state}`);
                         } else {
-                            node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                            utils.setStatusUnchanged(node, `state: ${node.state}`);
                         }
                     }
                     // Output latch value regardless
@@ -49,19 +47,19 @@ module.exports = function(RED) {
                     break;
                 case "reset":
                     if (node.state === false) {
-                        node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                        utils.setStatusUnchanged(node, `state: ${node.state}`);
                     } else {
                         if (msg.payload) {
                             node.state = false;
-                            node.status({ fill: "blue", shape: "dot", text: `state: ${node.state}` });
+                            utils.setStatusChanged(node, `state: ${node.state}`);
                         } else {
-                            node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                            utils.setStatusUnchanged(node, `state: ${node.state}`);
                         }
                     }
                     send({ payload: node.state });
                     break;
                 default:
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done("Unknown context");
                     return;
             }