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

package/nodes/global-getter.html

@@ -11,6 +11,15 @@
             <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>
@@ -29,7 +38,8 @@
         defaults: {
             name: { value: "" },
             targetNode: { value: "", required: true },
-            outputProperty: { value: "payload", required: true }
+            outputProperty: { value: "payload", required: true },
+            updates: { value: "always", required: true }
         },
         inputs: 1,
         outputs: 1,
@@ -39,10 +49,10 @@
                 const target = RED.nodes.node(this.targetNode);
                 if (target) {
                     let lbl = target.path || target.name;
-                    if(lbl && lbl.includes(":")) {
-                        lbl = lbl.split(":")[3];
+                    if(lbl && lbl.startsWith("#") && lbl.includes(":")) {
+                        lbl = lbl.substring(lbl.indexOf(":") + 1);
                     }
-                    return "Get: " + lbl;
+                    return "get: " + lbl;
                 }
             }
             return this.name || "global get";
@@ -51,12 +61,13 @@
         oneditprepare: function() {
             const node = this;
             
-            // 1. Populate Dropdown
             let candidateNodes = [];
             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})` : "")
@@ -67,62 +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 }]
             });
 
-            // 2. Output Property Selector
-            $("#node-input-outputProperty").typedInput({
-                types: ['msg']
-            });
+            $("#node-input-outputProperty").typedInput({ types: ['msg'] });
 
-            // 3. Find Button Logic
             $("#node-config-find-source").on("click", function() {
                 const selectedId = $("#node-input-targetNode").val();
-                if (selectedId) {
-                    // Node-RED API to jump to a node
-                    RED.view.reveal(selectedId);
-                } else {
-                    RED.notify("Please select a source node first.", "warning");
-                }
+                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 
-: source (any) : Select the source 'global-setter' node to get the variable from.
-: output (string) : The output property to store the variable value in.
-
-### Outputs
-: payload (any) : The global variable value
-: topic (string) : The variable name/path used to store the value.
-: units (string) : The units associated with the value, if any. Also supports nested units at `msg.<inputProperty>.units`.
-: metadata (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.
-
-Configurable output property allows chaining multiple getters in series if only interested in the value.
-
-### 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

@@ -4,47 +4,81 @@ module.exports = function(RED) {
         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;
-                const storedObject = globalContext.get(setterNode.varName, setterNode.storeName);
+            if (storedObject !== undefined) {
                 
-                if (storedObject !== undefined) {
-                    let val = storedObject;
-                    let units = null;
-                    let meta = {};
-
-                    // CHECK: Is this wrapper format?
-                    if (storedObject && typeof storedObject === 'object' && storedObject.hasOwnProperty('value') && storedObject.hasOwnProperty('meta')) {
-                        // Yes: Unwrap it
-                        val = storedObject.value;
-                        units = storedObject.units;
-                        meta = storedObject.meta;
-                    } else {
-                        // Legacy/Raw: Metadata is limited
-                        meta = { path: setterNode.varName, legacy: true };
-                    }
+                // CHECK: Is this our Wrapper Format? (Created by Global Setter)
+                if (storedObject && typeof storedObject === 'object' && storedObject.hasOwnProperty('value')) {
                     
-                    RED.util.setMessageProperty(msg, node.outputProperty, val);
-                    
-                    msg.topic = setterNode.varName;
-                    
-                    msg.units = units;
+                    // 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);
 
-                    msg.metadata = meta; 
-                    
-                    node.status({ fill: "blue", shape: "dot", text: `Get: ${val}` });
-                    node.send(msg);
                 } else {
-                    node.status({ fill: "red", shape: "ring", text: "Global variable undefined" });
+                    // 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

@@ -8,12 +8,24 @@
         <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 Property</label>
+        <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. 
-        When this node is redeployed or deleted, it will automatically remove the variable from memory.
+        <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>
 
@@ -24,7 +36,10 @@
         defaults: {
             name: { value: "" },
             path: { value: "", required: true },
-            property: { value: "payload", required: true }
+            property: { value: "payload", required: true },
+            defaultValue: { value: "", required: true },
+            writePriority: { value: "16", required: true },
+            writePriorityType: { value: "dropdown" }
         },
         inputs: 1,
         outputs: 1,
@@ -32,21 +47,45 @@
         label: function() {
             let lbl = this.path;
             if (lbl && lbl.startsWith("#") && lbl.includes(":")) {
-                lbl = lbl.split(":")[3];
+                lbl = lbl.substring(lbl.indexOf(":") + 1);
             }
-            return this.name || "Set: " + 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'] });
 
-            // Input Property Selector
-            $("#node-input-property").typedInput({
-                types: ['msg']
-            });
+            $("#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>

package/nodes/global-setter.js

@@ -1,55 +1,170 @@
+
 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.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) {
-                // READ from the configured property
-                const valueToStore = RED.util.getMessageProperty(msg, node.inputProperty);
-
-                if (valueToStore !== undefined) {
-                    const globalContext = node.context().global;
-
-                    // 1. Try to find units in the standard location (msg.units)
-                    // 2. If not found, check if the input property itself is an object containing .units
-                    let capturedUnits = msg.units; 
-                    
-                    // Optional: Deep check if msg.payload was an object that contained units
-                    if (!capturedUnits && typeof valueToStore === 'object' && valueToStore !== null && valueToStore.units) {
-                         capturedUnits = valueToStore.units;
-                    }
-                    
-                    // Create wrapper with simplified metadata
-                    const storedObject = {
-                        value: valueToStore,
-                        topic: node.varName,
-                        units: capturedUnits,
-                        meta: {
-                            sourceId: node.id,
-                            sourceName: node.name || config.path,
-                            sourcePath: node.varName,
-                            lastSet: new Date().toISOString()
-                        }
+                const inputValue = RED.util.getMessageProperty(msg, node.inputProperty);
+                const globalContext = node.context().global;
+
+                // 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: {}
                     };
-                    
-                    node.status({ fill: "blue", shape: "dot", text: `Set: ${storedObject.value}` });
-                    globalContext.set(node.varName, storedObject, node.storeName);
                 }
-            }
 
+                // 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;
+                    }
+                }
+                
+                // 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;
+                }
+
+                // 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) {
-            // Do NOT prune if Node-RED is simply restarting or deploying.
             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 {