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

package/nodes/modulo-block.js

@@ -1,23 +1,24 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function ModuloBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            slots: parseInt(config.slots),
-            inputs: Array(parseInt(config.slots) || 2).fill(1),
-            lastResult: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.slots = parseInt(config.slots);
+        node.inputs = Array(parseInt(config.slots) || 2).fill(1);
+        node.lastResult = null;
 
         // Validate initial config
-        if (isNaN(node.runtime.slots) || node.runtime.slots < 1) {
-            node.runtime.slots = 2;
-            node.runtime.inputs = Array(2).fill(1);
-            node.status({ fill: "red", shape: "ring", text: "invalid slots, using 2" });
+        if (isNaN(node.slots) || node.slots < 1) {
+            node.slots = 2;
+            node.inputs = Array(2).fill(1);
+            utils.setStatusError(node, "invalid slots, using 2");
         } else {
-            node.status({ fill: "green", shape: "dot", text: `name: ${node.runtime.name || "modulo"}, slots: ${node.runtime.slots}` });
+            utils.setStatusOK(node, `name: ${node.name || "modulo"}, slots: ${node.slots}`);
         }
 
         node.on("input", function(msg, send, done) {
@@ -25,35 +26,36 @@ 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;
             }
 
             // Check for missing context or payload
             if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
-                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;
                 }
@@ -64,56 +66,56 @@ module.exports = function(RED) {
             if (msg.context === "slots") {
                 const newSlots = parseInt(msg.payload);
                 if (isNaN(newSlots) || newSlots < 1) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid slots" });
+                    utils.setStatusError(node, "invalid slots");
                     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: ${newSlots}` });
+                node.slots = newSlots;
+                node.inputs = Array(newSlots).fill(1);
+                node.lastResult = null;
+                utils.setStatusOK(node, `slots: ${newSlots}`);
                 if (done) done();
                 return;
             }
 
             if (msg.context.startsWith("in")) {
-                const 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;
                 const newValue = parseFloat(msg.payload);
                 if (isNaN(newValue) || !isFinite(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: "modulo by zero" });
+                    utils.setStatusError(node, "modulo by zero");
                     if (done) done();
                     return;
                 }
-                node.runtime.inputs[slotIndex] = newValue;
+                node.inputs[slotIndex] = newValue;
 
                 // Calculate modulo
-                const result = node.runtime.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc % val, node.runtime.inputs[0]);
-                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, node.inputs[0]);
+                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;
             }
 
-            node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+            utils.setStatusWarn(node, "unknown context");
             if (done) done("Unknown context");
         });
 

package/nodes/multiply-block.js

@@ -1,24 +1,25 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function MultiplyBlockNode(config) {
         RED.nodes.createNode(this, config);
         
         const node = this;
         
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            slots: parseInt(config.slots),
-            inputs: Array(parseInt(config.slots) || 2).fill(1),
-            lastResult: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.slots = parseInt(config.slots);
+        node.inputs = Array(parseInt(config.slots) || 2).fill(1);
+        node.lastResult = null;
 
         // Validate initial config
-        if (isNaN(node.runtime.slots) || node.runtime.slots < 1) {
-            node.runtime.slots = 2;
-            node.runtime.inputs = Array(2).fill(1);
-            node.status({ fill: "red", shape: "ring", text: "invalid slots, using 2" });
+        if (isNaN(node.slots) || node.slots < 1) {
+            node.slots = 2;
+            node.inputs = Array(2).fill(1);
+            utils.setStatusError(node, "invalid slots, using 2");
         } else {
-            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) {
@@ -26,81 +27,82 @@ 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;
             }
 
             // 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" });
+                    utils.setStatusError(node, "invalid slots");
                     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 = newSlots;
+                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;
                 }
-                node.runtime.inputs[slotIndex] = newValue;
+                node.inputs[slotIndex] = newValue;
                 // Calculate product
-                const product = node.runtime.inputs.reduce((acc, val) => acc * val, 1);
-                const isUnchanged = product === node.runtime.lastResult;
-                node.status({
-                    fill: "blue",
-                    shape: isUnchanged ? "ring" : "dot",
-                    text: `in: ${msg.context}=${newValue.toFixed(2)}, out: ${product.toFixed(2)}`
-                });
-                if (!isUnchanged) {
-                    node.runtime.lastResult = product;
-                    send({ payload: product });
+                const product = node.inputs.reduce((acc, val) => acc * val, 1);
+                const isUnchanged = product === node.lastResult;
+                const statusText = `in: ${msg.context}=${newValue.toFixed(2)}, out: ${product.toFixed(2)}`;
+                if (isUnchanged) {
+                    utils.setStatusUnchanged(node, statusText);
+                } else {
+                    utils.setStatusChanged(node, statusText);
                 }
+                node.lastResult = product;
+                send({ payload: product });
                 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/negate-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>
 </script>
 
 <script type="text/javascript">
@@ -10,7 +14,8 @@
         category: "bldgblocks control",
         color: "#301934",
         defaults: {
-            name: { value: "" }
+            name: { value: "" },
+            inputProperty: { value: "payload" }
         },
         inputs: 1,
         outputs: 1,
@@ -28,17 +33,22 @@
 Negates a number or boolean input value.
 
 ### Inputs
-: payload (number | boolean) : Value to negate (number or boolean).
+: input-property (number | boolean) : Value to negate (number or boolean), read from the configured Input Property.
 
 ### Outputs
 : payload (number | boolean) : Negated value (-number or !boolean).
 
-### Details
-Negates `msg.payload` in a passthrough manner, updating the original message.
-- For numbers, outputs the negative (e.g., 5 becomes -5). 
-- For booleans, outputs the inverse (e.g., true becomes false). 
+### Properties
+: name (string) : Display name in editor.
+: inputProperty (string) : Message property to read input from (default: `payload`). Supports nested properties (e.g., `data.value`).
 
-Preserves other message properties (e.g., `msg.topic`, `msg.context`).
+### Details
+Negates a number or boolean value in a passthrough manner, updating the original message.
+- Reads input from the message property specified in the **Input Property** field (default: `msg.payload`)
+- For numbers, outputs the negative (e.g., 5 becomes -5)
+- For booleans, outputs the inverse (e.g., true becomes false)
+- Output is always written to `msg.payload`
+- Preserves other message properties (e.g., `msg.topic`, `msg.context`)
 
 ### Status
 - Green (dot): Configuration update

package/nodes/negate-block.js

@@ -1,39 +1,45 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function NegateBlockNode(config) {
         RED.nodes.createNode(this, config);
         
         const node = this;
         
-        // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            lastOutput: null
-        };
+        // Initialize state
+        node.inputProperty = config.inputProperty || "payload";
+        node.lastOutput = null;
 
         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: "missing message" });
+                utils.setStatusError(node, "missing message");
                 if (done) done();
                 return;
             }
 
-            // Check for missing payload
-            if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing input" });
+            // Get input value from the specified 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;
             }
 
-            const inputValue = msg.payload;
             let outputValue;
             let statusText;
 
             if (typeof inputValue === "number") {
                 if (isNaN(inputValue)) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid input: NaN" });
+                    utils.setStatusError(node, "invalid input: NaN");
                     if (done) done();
                     return;
                 }
@@ -43,20 +49,20 @@ module.exports = function(RED) {
                 outputValue = !inputValue;
                 statusText = `in: ${inputValue}, out: ${outputValue}`;
             } else {
-                node.status({ fill: "red", shape: "ring", text: "Unsupported type" });
+                utils.setStatusError(node, "Unsupported type");
                 if (done) done();
                 return;
             }
 
             // Check for unchanged output
-            const isUnchanged = outputValue === node.runtime.lastOutput;
-            node.status({
-                fill: "blue",
-                shape: isUnchanged ? "ring" : "dot",
-                text: statusText
-            });
+            const isUnchanged = outputValue === node.lastOutput;
+            if (isUnchanged) {
+                utils.setStatusUnchanged(node, statusText);
+            } else {
+                utils.setStatusChanged(node, statusText);
+            }
 
-            node.runtime.lastOutput = outputValue;
+            node.lastOutput = outputValue;
             msg.payload = outputValue;
             send(msg);
 

package/nodes/network-point-read.html

@@ -0,0 +1,128 @@
+<script type="text/html" data-template-name="network-point-read">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on canvas"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Point #101">
+    </div>
+    <div class="form-row">
+        <label for="node-input-pointId" title="Point ID to cache (e.g., 301)"><i class="fa fa-hashtag"></i> Point ID</label>
+        <input type="number" id="node-input-pointId" placeholder="301" min="0" required>
+    </div>
+    <hr style="margin: 10px 0;">
+    <div class="form-row">
+        <label for="node-input-outputProperty" title="Set output message property"><i class="fa fa-arrow-right"></i> Target</label>
+        <input type="text" id="node-input-outputProperty" placeholder="payload">
+    </div>
+    <div class="form-row">
+        <label for="node-input-bridgeNodeId" title="Select which network bridge to query"><i class="fa fa-link"></i> Network Bridge</label>
+        <input type="text" id="node-input-bridgeNodeId" style="width: calc(70% - 45px);">
+        <button id="node-config-find-bridge" class="editor-button" style="margin-left: 5px; width: 40px;" title="Find Bridge Node">
+            <i class="fa fa-search"></i>
+        </button>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("network-point-read", {
+        category: "bldgblocks network",
+        color: "#3090C7",
+        defaults: {
+            name: { value: "" },
+            outputProperty: { value: "payload" },
+            pointId: { 
+                value: 0, 
+                required: true,
+                validate: function(v) { 
+                    return !isNaN(parseInt(v)) && parseInt(v) >= 0; 
+                }
+            },
+            bridgeNodeId: { 
+                value: "", 
+                required: true
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["trigger (from inject/timer)"],
+        outputLabels: ["value update / response"],
+        icon: "font-awesome/fa-refresh",
+        paletteLabel: "network point read",
+        label: function() {
+            const id = this.pointId ? ` #${this.pointId}` : " (unconfigured)";
+            const bridgeName = this.bridgeNodeId ? ` → ${RED.nodes.node(this.bridgeNodeId)?.name || "bridge"}` : "";
+            return this.name ? `${this.name}${id}${bridgeName}` : `network point read${id}${bridgeName}`;
+        },
+        oneditprepare: function() {
+            const node = this;
+            
+            let candidateNodes = [];
+            RED.nodes.eachNode(function(n) {
+                if (n.type === 'network-service-bridge') {
+                    candidateNodes.push({
+                        value: n.id,
+                        label: n.name || "(unnamed bridge)"
+                    });
+                }
+            });
+
+            candidateNodes.sort((a, b) => a.label.localeCompare(b.label));
+
+            $("#node-input-bridgeNodeId").typedInput({
+                types: [{ value: "bridge", options: candidateNodes }]
+            });
+$("#node-input-outputProperty").typedInput({
+                types: ['msg']
+            });
+
+            
+            // Find button
+            $("#node-config-find-bridge").on("click", function() {
+                if (node.bridgeNodeId) {
+                    RED.viewport.reveal(node.bridgeNodeId);
+                }
+            });
+        },
+        oneditsave: function() {
+            // Optional: log configuration
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="network-point-read">
+Caches a remote point value and serves requests immediately (non-blocking).
+
+Ideal for flows that need current point values without waiting for network latency.
+
+### Inputs
+: action (string) : Command - `getPoint` to request cached value, `resetCache` to clear cache.
+: pointId (number) : The remote point ID to query (e.g., 301).
+: payload (any) : Trigger message from inject or timer node.
+
+### Outputs
+: payload (number | string | boolean) : Cached point value on update.
+: pointId (number) : Echo of queried point ID.
+: cached (boolean) : true if value served from cache, false if fresh from network.
+: age (number) : Cache age in milliseconds.
+: action (string) : getPointResponse or pointUpdate.
+
+### Details
+Caching Architecture:
+1. External trigger - Inject node controls polling timing
+2. Event-based communication - Sends request to selected bridge
+3. Immediate serving - Returns cached value on getPoint requests
+4. Non-blocking - Logic flows never wait for network roundtrip
+
+Use With:
+- network-service-bridge - Routes requests via WebSocket
+- History nodes - Feed cached poi
+
+### 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>