@bldgblocks/node-red-contrib-control 0.1.29 → 0.1.31

package/nodes/global-getter.html

@@ -3,22 +3,43 @@
         <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-targetNode"><i class="fa fa-crosshairs"></i> Source</label>
-        <input type="text" id="node-input-targetNode" style="width:70%;">
+        <input type="text" id="node-input-targetNode" style="width: calc(70% - 45px);">
+        <button id="node-config-find-source" class="editor-button" style="margin-left: 5px; width: 40px;" title="Find Source Node">
+            <i class="fa fa-search"></i>
+        </button>
     </div>
+
+    <!-- NEW: Trigger Mode Selection -->
+    <div class="form-row">
+        <label for="node-input-updates"><i class="fa fa-bolt"></i> Trigger</label>
+        <select id="node-input-updates" style="width: 70%;">
+            <option value="input">Manual (On Input Only)</option>
+            <option value="always">Reactive (On Input & Update)</option>
+        </select>
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-outputProperty"><i class="fa fa-arrow-right"></i> Output</label>
+        <input type="text" id="node-input-outputProperty" placeholder="payload" style="width:70%;">
+    </div>
+
     <div class="form-tips">
-        Targeting by Node ID allows the source path to change without breaking this link.
+        <b>Note:</b> Targeting by Node ID allows the source path to change without breaking this link.
     </div>
 </script>
 
 <script type="text/javascript">
     RED.nodes.registerType('global-getter', {
         category: 'control',
-        color: '#301934',
+        color: '#3FADB5',
         defaults: {
             name: { value: "" },
-            targetNode: { value: "", required: true } 
+            targetNode: { value: "", required: true },
+            outputProperty: { value: "payload", required: true },
+            updates: { value: "always", required: true }
         },
         inputs: 1,
         outputs: 1,
@@ -27,12 +48,11 @@
             if (this.targetNode) {
                 const target = RED.nodes.node(this.targetNode);
                 if (target) {
-                    // Display the path, removing the #store: prefix for readability in the label if present
                     let lbl = target.path || target.name;
-                    if(lbl && lbl.includes(":")) {
-                        lbl = lbl.split(":").pop();
+                    if(lbl && lbl.startsWith("#") && lbl.includes(":")) {
+                        lbl = lbl.substring(lbl.indexOf(":") + 1);
                     }
-                    return "Get: " + lbl;
+                    return "get: " + lbl;
                 }
             }
             return this.name || "global get";
@@ -45,7 +65,9 @@
             RED.nodes.eachNode(function(n) {
                 if (n.type === 'global-setter') {
                     let displayPath = n.path || "No Path";
-
+                    if (displayPath.startsWith("#") && displayPath.includes(":")) {
+                        displayPath = displayPath.substring(displayPath.indexOf(":") + 1);
+                    }
                     candidateNodes.push({
                         value: n.id,
                         label: displayPath + (n.name ? ` (${n.name})` : "")
@@ -56,41 +78,16 @@
             candidateNodes.sort((a, b) => a.label.localeCompare(b.label));
 
             $("#node-input-targetNode").typedInput({
-                types: [{
-                    value: "target",
-                    options: candidateNodes
-                }]
+                types: [{ value: "target", options: candidateNodes }]
+            });
+
+            $("#node-input-outputProperty").typedInput({ types: ['msg'] });
+
+            $("#node-config-find-source").on("click", function() {
+                const selectedId = $("#node-input-targetNode").val();
+                if (selectedId) { RED.view.reveal(selectedId); } 
+                else { RED.notify("Please select a source node first.", "warning"); }
             });
         }
     });
 </script>
-
-<!-- Help Section -->
-<script type="text/markdown" data-help-name="global-getter">
-Manage a global variable in a repeatable way.
-
-### Inputs 
-
-### Outputs
-: payload (any) : The global variable value
-: topic (string) : The variable name/path used to store the value.
-: globalMetadata (object) : Metadata about the global variable (store, path).
-
-### Details
-Global variables are meant to be retrieved in other places, this necessarily means managing the same string in multiple places. 
-
-This node allows you to get a global variable while supporting rename and deletion.
-
-It links to a `global-setter` node by Node ID, so if that node's path is changed, this node will still work.
-
-### 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/global-getter.js

@@ -3,40 +3,83 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
         node.targetNodeId = config.targetNode;
+        node.outputProperty = config.outputProperty || "payload";
+        node.updates = config.updates;
 
-        node.on('input', function(msg) {
-            const setterNode = RED.nodes.getNode(node.targetNodeId);
+        const setterNode = RED.nodes.getNode(node.targetNodeId);
+        
+        // --- HELPER: Process Wrapper and Send Msg ---
+        function sendValue(storedObject, msgToReuse) {
+            const msg = msgToReuse || {}; 
 
-            if (setterNode && setterNode.varName) {
-                const globalContext = node.context().global;
-                
-                // Retrieve the wrapper object
-                const storedObject = globalContext.get(setterNode.varName, setterNode.storeName);
+            if (storedObject !== undefined) {
                 
-                if (storedObject !== undefined) {
-                    // CHECK: Is this our wrapper format?
-                    if (storedObject && typeof storedObject === 'object' && storedObject.hasOwnProperty('value') && storedObject.hasOwnProperty('meta')) {
-                        // Yes: Unwrap it
-                        msg.payload = storedObject.value;
-                        msg.globalMetadata = storedObject.meta; // Expose the ID/Metadata here
-                    } else {
-                        // No: It's legacy/raw data, just pass it through
-                        msg.payload = storedObject;
-                    }
-                    
-                    msg.topic = setterNode.varName; 
+                // CHECK: Is this our Wrapper Format? (Created by Global Setter)
+                if (storedObject && typeof storedObject === 'object' && storedObject.hasOwnProperty('value')) {
                     
-                    node.status({ fill: "blue", shape: "dot", text: `Get: ${msg.payload}` });
-                    node.send(msg);
+                    // 1. Separate the Value from everything else (Rest operator)
+                    // 'attributes' will contain: priority, units, metadata, topic, etc.
+                    const { value, ...attributes } = storedObject;
+
+                    // 2. Set the Main Output (e.g. msg.payload = 75)
+                    RED.util.setMessageProperty(msg, node.outputProperty, value);
+
+                    // 3. Merge all attributes onto the msg root
+                    // This automatically handles priority, units, metadata, and any future fields
+                    Object.assign(msg, attributes);
+
                 } else {
-                    // Variable exists in config but not in memory yet
-                    // Optional: warn or just do nothing
+                    // Handle Legacy/Raw values (not created by your Setter)
+                    RED.util.setMessageProperty(msg, node.outputProperty, storedObject);
+                    msg.metadata = { path: setterNode ? setterNode.varName : "unknown", legacy: true };
                 }
+                
+                // Visual Status
+                const valDisplay = RED.util.getMessageProperty(msg, node.outputProperty);
+                node.status({ fill: "blue", shape: "dot", text: `Get: ${valDisplay}` });
+                
+                node.send(msg);
+
+            } else {
+                node.status({ fill: "red", shape: "ring", text: "global variable undefined" });
+            }
+        }
+
+        // --- 1. HANDLE MANUAL INPUT ---
+        node.on('input', function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            if (setterNode && setterNode.varName) {
+                const globalContext = node.context().global;
+                const storedObject = globalContext.get(setterNode.varName, setterNode.storeName);
+                sendValue(storedObject, msg);
             } else {
                 node.warn("Source node not found or not configured.");
                 node.status({ fill: "red", shape: "ring", text: "Source node not found" });
             }
+            
+            if (done) done();
+        });
+
+        // --- 2. HANDLE REACTIVE UPDATES ---
+        let updateListener = null;
+
+        if (node.updates === 'always' && setterNode && setterNode.varName) {
+            updateListener = function(evt) {
+                if (evt.key === setterNode.varName && evt.store === setterNode.storeName) {
+                    // Pass data directly from event
+                    sendValue(evt.data, {}); 
+                }
+            };
+            RED.events.on("bldgblocks-global-update", updateListener);
+        }
+
+        // --- CLEANUP ---
+        node.on('close', function() {
+            if (updateListener) {
+                RED.events.removeListener("bldgblocks-global-update", updateListener);
+            }
         });
     }
     RED.nodes.registerType("global-getter", GlobalGetterNode);
-}
+}

package/nodes/global-setter.html

@@ -5,39 +5,87 @@
     </div>
     <div class="form-row">
         <label for="node-input-path"><i class="fa fa-sitemap"></i> Global Path</label>
-        <input type="text" id="node-input-path" placeholder="furnace/outputs/heat">
+        <input type="text" id="node-input-path" style="width: 70%;" placeholder="furnace/outputs/heat">
     </div>
+    <div class="form-row">
+        <label for="node-input-property"><i class="fa fa-ellipsis-h"></i> Input</label>
+        <input type="text" id="node-input-property" style="width:70%;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-writePriority" title="Priority is evaluated for final value when using global-setter/getter nodes."><i class="fa fa-sort-numeric-asc"></i> Priority</label>
+        <input type="text" id="node-input-writePriority" placeholder="single">
+        <input type="hidden" id="node-input-writePriorityType">
+    </div>
+    
+    <hr>
+    
+    <div class="form-row">
+        <label for="node-input-defaultValue" title="Static default value to ensure one exists. You may write to default through message configuration."><i class="fa fa-undo"></i> Default</label>
+        <input type="text" id="node-input-defaultValue" placeholder="e.g. 0 or false">
+    </div>
+
     <div class="form-tips">
-        <b>Note:</b> Use the dropdown inside the Path input to select a specific Context Store (File, Memory, etc). 
-        When this node is redeployed or deleted, it will automatically remove (prune) the variable from that store.
+        <b>Note:</b> This node writes to the selected <b>Priority Level</b>. The actual Global Variable value will be the highest active priority.
     </div>
 </script>
 
 <script type="text/javascript">
     RED.nodes.registerType('global-setter', {
         category: 'control',
-        color: '#301934',
+        color: '#E2D96E',
         defaults: {
             name: { value: "" },
-            path: { value: "", required: true }
+            path: { value: "", required: true },
+            property: { value: "payload", required: true },
+            defaultValue: { value: "", required: true },
+            writePriority: { value: "16", required: true },
+            writePriorityType: { value: "dropdown" }
         },
         inputs: 1,
         outputs: 1,
         icon: "font-awesome/fa-align-right",
         label: function() {
-            // Remove #store: prefix for cleaner label
             let lbl = this.path;
             if (lbl && lbl.startsWith("#") && lbl.includes(":")) {
-                lbl = lbl.split(":")[3];
+                lbl = lbl.substring(lbl.indexOf(":") + 1);
             }
-            return this.name || lbl || "global set";
+            return this.name || "set: " + lbl || "global set";
         },
         paletteLabel: "global set",
         oneditprepare: function() {
-            // RESTRICT TO GLOBAL ONLY
-            $("#node-input-path").typedInput({
-                types: ['global']
-            });
+            // These are read as strings not evaluated typed-inputs.
+            $("#node-input-path").typedInput({ types: ['global'] });
+            // getMessageProperty handles msg access on the incoming message at the specified path.
+            $("#node-input-property").typedInput({ types: ['msg'] });
+            // Default for the default value, meaning it should only be manually set. You can still pass default values through messages.
+            $("#node-input-defaultValue").typedInput({ types: ['str','num','bool'] });
+
+            $("#node-input-writePriority").typedInput({
+                default: "dropdown",
+                types: [{
+                    value: "dropdown",
+                    options: [
+                        { value: "1", label: "1 (Life Safety)"},
+                        { value: "2", label: "2"},
+                        { value: "3", label: "3"},
+                        { value: "4", label: "4"},
+                        { value: "5", label: "5"},
+                        { value: "6", label: "6"},
+                        { value: "7", label: "7"},
+                        { value: "8", label: "8 (Manual Operator)"},
+                        { value: "9", label: "9"},
+                        { value: "10", label: "10"},
+                        { value: "11", label: "11"},
+                        { value: "12", label: "12"},
+                        { value: "13", label: "13"},
+                        { value: "14", label: "14"},
+                        { value: "15", label: "15"},
+                        { value: "16", label: "16 (Schedule/Logic)"},
+                        { value: "default", label: "default (fallback)"},
+                    ]
+                }, "msg", "flow"],
+                typeField: "#node-input-writePriorityType"
+            }).typedInput("type", node.writePriorityType).typedInput("value", node.writePriority);
         }
     });
 </script>
@@ -48,6 +96,8 @@ Manage a global variable in a repeatable way.
 
 ### Inputs 
 : payload (any) : Input payload is passed through unchanged.
+: property (string) : The input property where the value is taken from.
+: units (string) : The units associated with the value, if any. Also supports nested units at `msg.<inputProperty>.units`.
 
 ### Outputs
 : payload (any) : Original payload.

package/nodes/global-setter.js

@@ -1,38 +1,171 @@
+
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function GlobalSetterNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
         
         const parsed = RED.util.parseContextStore(config.path);
-        
         node.varName = parsed.key;
         node.storeName = parsed.store;
+        node.inputProperty = config.property;        
+        node.defaultValue = config.defaultValue;
+        node.writePriority = config.writePriority;
+        
+        // Cast default value logic
+        if(!isNaN(node.defaultValue) && node.defaultValue !== "") node.defaultValue = Number(node.defaultValue);
+        if(node.defaultValue === "true") node.defaultValue = true;
+        if(node.defaultValue === "false") node.defaultValue = false;
+
+        // --- HELPER: Calculate Winner ---
+        function calculateWinner(state) {
+            for (let i = 1; i <= 16; i++) {
+                if (state.priority[i] !== undefined && state.priority[i] !== null) {
+                    return state.priority[i];
+                }
+            }
+            return state.defaultValue;
+        }
+
+        node.isBusy = false;
+
+        node.on('input', async function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid msg
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }  
+
+            // Evaluate dynamic properties
+            try {
+
+                // 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" });
+                    if (done) done(); 
+                    return;
+                }
+
+                // Lock node during evaluation
+                node.isBusy = true;
+
+                // Begin evaluations
+                const evaluations = [];                    
+                
+                evaluations.push(
+                    utils.requiresEvaluation(config.writePriorityType) 
+                        ? utils.evaluateNodeProperty( config.writePriority, config.writePriorityType, node, msg )
+                        : Promise.resolve(config.writePriority),
+                );
+
+                const results = await Promise.all(evaluations);   
+
+                // Update runtime with evaluated values
+                node.writePriority = results[0];
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            } finally {
+                // Release, all synchronous from here on
+                node.isBusy = false;
+            }
 
-        node.on('input', function(msg) {
             if (node.varName) {
+                const inputValue = RED.util.getMessageProperty(msg, node.inputProperty);
                 const globalContext = node.context().global;
-                
-                // Create a clean wrapper object to store in global context
-                const storedObject = {
-                    value: msg.payload,
-                    meta: {
-                        sourceId: node.id,
-                        sourceName: node.name || config.path,
-                        topic: msg.topic,
-                        ts: Date.now()
+
+                // Get existing state or initialize new
+                let state = globalContext.get(node.varName, node.storeName);
+                if (!state || typeof state !== 'object' || !state.priority) {
+                    state = {
+                        value: null,
+                        defaultValue: node.defaultValue,
+                        priority: {
+                            1: null,
+                            2: null,
+                            3: null,
+                            4: null,
+                            5: null,
+                            6: null,
+                            7: null,
+                            8: null,
+                            9: null,
+                            10: null,
+                            11: null,
+                            12: null,
+                            13: null,
+                            14: null,
+                            15: null,
+                            16: null,
+                        },
+                        metadata: {}
+                    };
+                }
+
+                // Update Default, can not be set null
+                if (node.writePriority === 'default') {
+                    state.defaultValue = inputValue !== null ? inputValue : node.defaultValue;
+                } else {
+                    const priority = parseInt(node.writePriority, 10);
+                    if (isNaN(priority) || priority < 1 || priority > 16) {
+                        node.status({ fill: "red", shape: "ring", text: `Invalid priority: ${node.writePriority}` });
+                        if (done) done();
+                        return;
                     }
-                };
+                }
                 
-                globalContext.set(node.varName, storedObject, node.storeName);
-            }
+                // Ensure defaultValue always has a value
+                if (state.defaultValue === null || state.defaultValue === undefined) {
+                    state.defaultValue = node.defaultValue;
+                }
+
+                // Update Specific Priority Slot
+                if (inputValue !== undefined) {
+                     state.priority[node.writePriority] = inputValue;
+                }
 
-            node.status({ fill: "blue", shape: "dot", text: `Set: ${msg.payload}` });
+                // Calculate Winner
+                state.value = calculateWinner(state);
+
+                // Update Metadata
+                state.metadata.sourceId = node.id;
+                state.metadata.lastSet = new Date().toISOString();
+                state.metadata.sourceName = node.name || config.path;
+                state.metadata.sourcePath = node.varName; 
+                state.metadata.store = node.storeName; 
+
+                // Units logic
+                let capturedUnits = msg.units; 
+                if (!capturedUnits && typeof inputValue === 'object' && inputValue !== null && inputValue.units) {
+                     capturedUnits = inputValue.units;
+                }
+                if(capturedUnits) state.units = capturedUnits;
+
+                // Save & Emit
+                globalContext.set(node.varName, state, node.storeName);
+                
+                node.status({ fill: "blue", shape: "dot", text: `P${node.writePriority}:${inputValue} > Val:${state.value}` });
+
+                // Fire Event
+                RED.events.emit("bldgblocks-global-update", {
+                    key: node.varName,
+                    store: node.storeName,
+                    data: state
+                });
+            }
+            
             node.send(msg);
+            if (done) done();
         });
 
-        // CLEANUP
         node.on('close', function(removed, done) {
-            if (node.varName) {
+            if (removed && node.varName) {
                 const globalContext = node.context().global;
                 globalContext.set(node.varName, undefined, node.storeName); 
             }

package/nodes/hysteresis-block.js

@@ -6,18 +6,13 @@ module.exports = function(RED) {
         const node = this;
         node.name = config.name;
         node.state = "within";
+        node.isBusy = false;
+        node.upperLimit = parseFloat(config.upperLimit);
+        node.lowerLimit = parseFloat(config.lowerLimit);
+        node.upperLimitThreshold = parseFloat(config.upperLimitThreshold);
+        node.lowerLimitThreshold = parseFloat(config.lowerLimitThreshold);
 
-        // Evaluate typed-input properties    
-        try {      
-            node.upperLimit = parseFloat(RED.util.evaluateNodeProperty( config.upperLimit, config.upperLimitType, node ));
-            node.lowerLimit = parseFloat(RED.util.evaluateNodeProperty( config.lowerLimit, config.lowerLimitType, node ));
-            node.upperLimitThreshold = parseFloat(RED.util.evaluateNodeProperty( config.upperLimitThreshold, config.upperLimitThresholdType, node ));
-            node.lowerLimitThreshold = parseFloat(RED.util.evaluateNodeProperty( config.lowerLimitThreshold, config.lowerLimitThresholdType, node ));
-        } catch (err) {
-            node.error(`Error evaluating properties: ${err.message}`);
-        }
-
-        node.on("input", function(msg, send, done) {
+        node.on("input", async function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             if (!msg) {
@@ -25,6 +20,67 @@ module.exports = function(RED) {
                 if (done) done();
                 return;
             }
+
+            // Evaluate dynamic properties
+            try {
+
+                // 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" });
+                    if (done) done(); 
+                    return;
+                }
+
+                // Lock node during evaluation
+                node.isBusy = true;
+
+                // Begin evaluations
+                const evaluations = [];                    
+                
+                evaluations.push(
+                    utils.requiresEvaluation(config.upperLimitType) 
+                        ? utils.evaluateNodeProperty(config.upperLimit, config.upperLimitType, node, msg)
+                            .then(val => parseFloat(val))
+                        : Promise.resolve(node.upperLimit),
+                );
+
+                evaluations.push(
+                    utils.requiresEvaluation(config.lowerLimitType) 
+                        ? utils.evaluateNodeProperty(config.lowerLimit, config.lowerLimitType, node, msg)
+                            .then(val => parseFloat(val))
+                        : Promise.resolve(node.lowerLimit),
+                );
+
+                evaluations.push(
+                    utils.requiresEvaluation(config.upperLimitThresholdType) 
+                        ? utils.evaluateNodeProperty(config.upperLimitThreshold, config.upperLimitThresholdType, node, msg)
+                            .then(val => parseFloat(val))
+                        : Promise.resolve(node.upperLimitThreshold),
+                );
+
+                evaluations.push(
+                    utils.requiresEvaluation(config.lowerLimitThresholdType) 
+                        ? utils.evaluateNodeProperty(config.lowerLimitThreshold, config.lowerLimitThresholdType, node, msg)
+                            .then(val => parseFloat(val))
+                        : Promise.resolve(node.lowerLimitThreshold),
+                );
+
+                const results = await Promise.all(evaluations);   
+
+                // Update runtime with evaluated values
+                if (!isNaN(results[0])) node.upperLimit = results[0];
+                if (!isNaN(results[1])) node.lowerLimit = results[1];
+                if (!isNaN(results[2])) node.upperLimitThreshold = results[2];
+                if (!isNaN(results[3])) node.lowerLimitThreshold = results[3];
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            } finally {
+                // Release, all synchronous from here on
+                node.isBusy = false;
+            }
             
             // Update typed-input properties if needed
             try {