@bldgblocks/node-red-contrib-control 0.1.26 → 0.1.28

package/nodes/changeover-block.html

@@ -5,10 +5,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-algorithm" title="Control algorithm type"><i class="fa fa-cog"></i> Algorithm</label>
-        <select id="node-input-algorithm">
-            <option value="single">Single Setpoint</option>
-            <option value="split">Split Setpoints</option>
-        </select>
+        <input type="text" id="node-input-algorithm" class="node-input-typed" placeholder="single">
+        <input type="hidden" id="node-input-algorithmType">
     </div>
     <div class="form-row single-only">
         <label for="node-input-setpoint" title="Target temperature setpoint (number from num, msg, flow, or global)"><i class="fa fa-thermometer-half"></i> Setpoint</label>
@@ -50,6 +48,18 @@
             Invalid
         </div>
     </div>
+
+    <div class="form-row specified-only" style="display: none;">
+        <label for="node-input-coolingOn" title="Temperature to turn cooling on (number from num, msg, flow, or global)"><i class="fa fa-snowflake-o"></i> Cooling On</label>
+        <input type="text" id="node-input-coolingOn" placeholder="74">
+        <input type="hidden" id="node-input-coolingOnType">
+    </div>
+    <div class="form-row specified-only" style="display: none;">
+        <label for="node-input-heatingOn" title="Temperature to turn heating on (number from num, msg, flow, or global)"><i class="fa fa-fire"></i> Heating On</label>
+        <input type="text" id="node-input-heatingOn" placeholder="66">
+        <input type="hidden" id="node-input-heatingOnType">
+    </div>
+
     <div class="form-row">
         <label for="node-input-swapTime" title="Minimum time before mode change (seconds, minimum 60, from num, msg, flow, or global)"><i class="fa fa-clock-o"></i> Swap Time</label>
         <input type="text" id="node-input-swapTime" class="node-input-typed" placeholder="300">
@@ -76,11 +86,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-operationMode" title="Operation mode"><i class="fa fa-cogs"></i> Operation Mode</label>
-        <select id="node-input-operationMode">
-            <option value="auto">Auto</option>
-            <option value="heat">Heat</option>
-            <option value="cool">Cool</option>
-        </select>
+        <input type="text" id="node-input-operationMode" placeholder="auto">
+        <input type="hidden" id="node-input-operationModeType">
     </div>
 </script>
 
@@ -91,6 +98,7 @@
         defaults: {
             name: { value: "" },
             algorithm: { value: "single" },
+            algorithmType: { value: "dropdown" },
             setpoint: { value: "70" },
             setpointType: { value: "num" },
             deadband: { value: "2" },
@@ -98,6 +106,10 @@
             heatingSetpointType: { value: "num" },
             coolingSetpoint: { value: "74" },
             coolingSetpointType: { value: "num" },
+            coolingOn: { value: "74" },
+            coolingOnType: { value: "num" },
+            heatingOn: { value: "66" },
+            heatingOnType: { value: "num" },
             extent: { value: "1" },
             swapTime: { value: "300" },
             swapTimeType: { value: "num" },
@@ -106,7 +118,8 @@
             maxTempSetpoint: { value: "90" },
             maxTempSetpointType: { value: "num"},
             initWindow: { value: "10" },
-            operationMode: { value: "auto" }
+            operationMode: { value: "auto" },
+            operationModeType: { value: "dropdown" },
         },
         inputs: 1,
         outputs: 1,
@@ -122,9 +135,37 @@
             const $algorithm = $("#node-input-algorithm");
             const $singleFields = $(".single-only");
             const $splitFields = $(".split-only");
+            const $specifiedFields = $(".specified-only");
 
             try {
                 // Initialize typed inputs
+                
+                $("#node-input-operationMode").typedInput({
+                    default: "dropdown",
+                    types: [{
+                        value: "dropdown",
+                        options: [
+                            { value: "auto", label: "Auto"},
+                            { value: "heat", label: "Heat"},
+                            { value: "cool", label: "Cool"},
+                        ]
+                    }, "msg", "flow", "global"],
+                    typeField: "#node-input-operationModeType"
+                }).typedInput("type", node.operationModeType).typedInput("value", node.operationMode);
+                
+                $("#node-input-algorithm").typedInput({
+                    default: "dropdown",
+                    types: [{
+                        value: "dropdown",
+                        options: [
+                            { value: "single", label: "Single"},
+                            { value: "split", label: "Split"},
+                            { value: "specified", label: "Specified"},
+                        ]
+                    }, "msg", "flow", "global"],
+                    typeField: "#node-input-algorithmType"
+                }).typedInput("type", node.algorithmType).typedInput("value", node.algorithm);
+
                 $("#node-input-setpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
@@ -143,6 +184,18 @@
                     typeField: "#node-input-coolingSetpointType"
                 }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
 
+                $("#node-input-heatingOn").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingOnType"
+                }).typedInput("type", node.heatingOnType || "num").typedInput("value", node.heatingOn);
+
+                $("#node-input-coolingOn").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingOnType"
+                }).typedInput("type", node.coolingOnType || "num").typedInput("value", node.coolingOn);
+
                 $("#node-input-swapTime").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
@@ -178,9 +231,20 @@
                     if ($algorithm.val() === "single") {
                         $singleFields.show();
                         $splitFields.hide();
-                    } else {
+                        $specifiedFields.hide();
+                    } else if ($algorithm.val() === "split") {
                         $singleFields.hide();
                         $splitFields.show();
+                        $specifiedFields.hide();
+                    } else if ($algorithm.val() === "specified") {
+                        $singleFields.hide();
+                        $splitFields.hide();
+                        $specifiedFields.show();
+                    } else {
+                        $algorithm.val("single");
+                        $singleFields.show();
+                        $splitFields.hide();
+                        $specifiedFields.hide();
                     }
                 }
 
@@ -188,7 +252,7 @@
                 toggleFields();
                 
             } catch (err) {
-                console.error("Error in changeover-block oneditprepare:", err);
+                console.error("Error in oneditprepare:", err);
             }
         }
     });

package/nodes/changeover-block.js

@@ -1,3 +1,5 @@
+//const { parse } = require('echarts/types/src/export/api/time.js');
+
 module.exports = function(RED) {
     const utils = require('./utils')(RED);
 
@@ -8,28 +10,24 @@ module.exports = function(RED) {
         // Initialize runtime state
         node.runtime = {
             name: config.name,
-            algorithm: config.algorithm,
-            operationMode: config.operationMode,
             initWindow: parseFloat(config.initWindow),
-            currentMode: (config.operationMode === "cool" ? "cooling" : "heating"),
             lastTemperature: null,
             lastModeChange: 0
         };
 
-        const typedProperties = ['setpoint', 'heatingSetpoint', 'coolingSetpoint', 'swapTime', 'deadband', 
-            'extent', 'minTempSetpoint', 'maxTempSetpoint'];
-
         // Evaluate typed-input properties    
-        try {            
-            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
-            node.runtime.setpoint = parseFloat(evaluatedValues.setpoint);
-            node.runtime.heatingSetpoint = parseFloat(evaluatedValues.heatingSetpoint);
-            node.runtime.coolingSetpoint = parseFloat(evaluatedValues.coolingSetpoint);
-            node.runtime.swapTime = parseFloat(evaluatedValues.swapTime);
-            node.runtime.deadband = parseFloat(evaluatedValues.deadband);
-            node.runtime.extent = parseFloat(evaluatedValues.extent);
-            node.runtime.minTempSetpoint = parseFloat(evaluatedValues.minTempSetpoint);
-            node.runtime.maxTempSetpoint = parseFloat(evaluatedValues.maxTempSetpoint);
+        try {     
+            node.runtime.setpoint = parseFloat(RED.util.evaluateNodeProperty( config.setpoint, config.setpointType, node ));
+            node.runtime.heatingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.heatingSetpoint, config.heatingSetpointType, node ));
+            node.runtime.coolingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.coolingSetpoint, config.coolingSetpointType, node ));
+            node.runtime.swapTime = parseFloat(RED.util.evaluateNodeProperty( config.swapTime, config.swapTimeType, node ));
+            node.runtime.deadband = parseFloat(RED.util.evaluateNodeProperty( config.deadband, config.deadbandType, node ));
+            node.runtime.extent = parseFloat(RED.util.evaluateNodeProperty( config.extent, config.extentType, node ));
+            node.runtime.minTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.minTempSetpoint, config.minTempSetpointType, node ));
+            node.runtime.maxTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.maxTempSetpoint, config.maxTempSetpointType, node ));  
+            node.runtime.algorithm = RED.util.evaluateNodeProperty( config.algorithm, config.algorithmType, node );
+            node.runtime.operationMode = RED.util.evaluateNodeProperty( config.operationMode, config.operationModeType, node );
+            node.runtime.currentMode = node.runtime.operationMode === "cool" ? "cooling" : "heating";          
         } catch (err) {
             node.error(`Error evaluating properties: ${err.message}`);
             if (done) done();
@@ -53,15 +51,37 @@ module.exports = function(RED) {
 
             // Update typed-input properties if needed
             try {    
-                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
-                node.runtime.setpoint = parseFloat(evaluatedValues.setpoint);
-                node.runtime.heatingSetpoint = parseFloat(evaluatedValues.heatingSetpoint);
-                node.runtime.coolingSetpoint = parseFloat(evaluatedValues.coolingSetpoint);
-                node.runtime.swapTime = parseFloat(evaluatedValues.swapTime);
-                node.runtime.deadband = parseFloat(evaluatedValues.deadband);
-                node.runtime.extent = parseFloat(evaluatedValues.extent);
-                node.runtime.minTempSetpoint = parseFloat(evaluatedValues.minTempSetpoint);
-                node.runtime.maxTempSetpoint = parseFloat(evaluatedValues.maxTempSetpoint);                
+                if (utils.requiresEvaluation(config.setpointType)) {
+                    node.runtime.setpoint = parseFloat(RED.util.evaluateNodeProperty( config.setpoint, config.setpointType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.heatingSetpointType)) {
+                    node.runtime.heatingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.heatingSetpoint, config.heatingSetpointType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.coolingSetpointType)) {
+                    node.runtime.coolingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.coolingSetpoint, config.coolingSetpointType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.swapTimeType)) {
+                    node.runtime.swapTime = parseFloat(RED.util.evaluateNodeProperty( config.swapTime, config.swapTimeType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.deadbandType)) {
+                    node.runtime.deadband = parseFloat(RED.util.evaluateNodeProperty( config.deadband, config.deadbandType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.extentType)) {
+                    node.runtime.extent = parseFloat(RED.util.evaluateNodeProperty( config.extent, config.extentType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.minTempSetpointType)) {
+                    node.runtime.minTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.minTempSetpoint, config.minTempSetpointType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.maxTempSetpointType)) {
+                    node.runtime.maxTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.maxTempSetpoint, config.maxTempSetpointType, node, msg )); 
+                }
+                if (utils.requiresEvaluation(config.algorithmType)) {
+                    node.runtime.algorithm = RED.util.evaluateNodeProperty( config.algorithm, config.algorithmType, node, msg );          
+                }    
+                if (utils.requiresEvaluation(config.operationModeType)) {
+                    node.runtime.operationMode = RED.util.evaluateNodeProperty( config.operationMode, config.operationModeType, node, msg );
+                    node.runtime.currentMode = node.runtime.operationMode === "cool" ? "cooling" : "heating";          
+                }
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -264,9 +284,12 @@ module.exports = function(RED) {
                 if (node.runtime.algorithm === "single") {
                     heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2;
                     coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2;
-                } else {
+                } else if (node.runtime.algorithm === "split") {
                     heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
                     coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
+                } else if (node.runtime.algorithm === "specified") {
+                    heatingThreshold = node.runtime.heatingOn - node.runtime.extent;
+                    coolingThreshold = node.runtime.coolingOn + node.runtime.extent;
                 }
 
                 if (temp < heatingThreshold) {
@@ -298,9 +321,12 @@ module.exports = function(RED) {
                 if (node.runtime.algorithm === "single") {
                     heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2;
                     coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2;
-                } else {
+                } else if (node.runtime.algorithm === "split") {
                     heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
                     coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
+                } else if (node.runtime.algorithm === "specified") {
+                    heatingThreshold = node.runtime.heatingOn - node.runtime.extent;
+                    coolingThreshold = node.runtime.coolingOn + node.runtime.extent;
                 }
 
                 let desiredMode = node.runtime.currentMode;
@@ -339,9 +365,12 @@ module.exports = function(RED) {
             if (node.runtime.algorithm === "single") {
                 effectiveHeatingSetpoint = node.runtime.setpoint - node.runtime.deadband / 2;
                 effectiveCoolingSetpoint = node.runtime.setpoint + node.runtime.deadband / 2;
-            } else {
+            } else if (node.runtime.algorithm === "split") {
                 effectiveHeatingSetpoint = node.runtime.heatingSetpoint;
                 effectiveCoolingSetpoint = node.runtime.coolingSetpoint;
+            } else if (node.runtime.algorithm === "specified") {
+                effectiveHeatingSetpoint = node.runtime.heatingOn;
+                effectiveCoolingSetpoint = node.runtime.coolingOn;
             }
 
             return [

package/nodes/delay-block.html

@@ -70,7 +70,7 @@
                 }).typedInput("type", node.delayOffType || "num").typedInput("value", node.delayOff);
 
             } catch (err) {
-                console.error("Error in hysteresis-block oneditprepare:", err);
+                console.error("Error in oneditprepare:", err);
             }
         }
     });

package/nodes/delay-block.js

@@ -11,13 +11,10 @@ module.exports = function(RED) {
             desired: false
         };
 
-        const typedProperties = ['delayOn', 'delayOff'];
-
         // Evaluate typed-input properties    
         try {   
-            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
-            node.runtime.delayOn = (parseFloat(evaluatedValues.delayOn)) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
-            node.runtime.delayOff = (parseFloat(evaluatedValues.delayOff)) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
+            node.runtime.delayOn = parseFloat(RED.util.evaluateNodeProperty( config.delayOn, config.delayOnType, node )) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
+            node.runtime.delayOff = parseFloat(RED.util.evaluateNodeProperty( config.delayOff, config.delayOffType, node )) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
         } catch (err) {
             node.error(`Error evaluating properties: ${err.message}`);
         }
@@ -33,9 +30,12 @@ module.exports = function(RED) {
 
             // Update typed-input properties if needed
             try {   
-                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
-                node.runtime.delayOn = parseFloat(evaluatedValues.delayOn) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
-                node.runtime.delayOff = parseFloat(evaluatedValues.delayOff) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
+                if (utils.requiresEvaluation(config.delayOnType)) {
+                    node.runtime.delayOn = parseFloat(RED.util.evaluateNodeProperty( config.delayOn, config.delayOnType, node, msg )) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
+                }
+                if (utils.requiresEvaluation(config.delayOffType)) {
+                    node.runtime.delayOff = parseFloat(RED.util.evaluateNodeProperty( config.delayOff, config.delayOffType, node, msg )) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
+                }
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();

package/nodes/enum-switch-block.html

@@ -0,0 +1,157 @@
+<script type="text/html" data-template-name="enum-switch-block">
+    <div class="form-row">
+        <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-property" title="Property to evaluate"><i class="fa fa-code"></i> Property</label>
+        <input type="text" id="node-input-property" placeholder="property">
+        <input type="hidden" id="node-input-propertyType">
+        <input type="hidden" id="node-input-outputs">
+    </div>
+    <div class="form-row">
+        <label><i class="fa fa-cogs"></i> Rules</label>
+        <div id="node-input-rules-container" style="border: 1px solid #999; padding: 5px; margin: 5px 0; max-height: 200px; overflow-y: auto;">
+            <input type="hidden" id="node-input-rules">
+            <div class="rule-template" style="display: none;">
+                <div class="form-row rule-item" style="margin-bottom: 5px; padding: 5px; border-bottom: 1px solid #eee; display: flex; align-items: center;">
+                    <input type="text" class="node-input-rule-value" placeholder="value to match" style="flex: 1; margin-right: 5px;">
+                    <button class="red-ui-button delete-rule" style="width: auto; padding: 0 8px;">
+                        <i class="fa fa-times"></i>
+                    </button>
+                </div>
+            </div>
+            <div id="node-input-rules-list"></div>
+            <button id="node-input-add-rule" class="red-ui-button" style="width: 100%; margin-top: 5px;">
+                <i class="fa fa-plus"></i> Add Rule
+            </button>
+        </div>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("enum-switch-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            property: { value: "payload" },
+            propertyType: { value: "msg" },
+            rules: { value: "[]" },
+            outputs: { value: 1 }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: function(index) {
+            try {
+                const rules = JSON.parse(this.rules || "[]");
+                if (rules[index]) {
+                    return rules[index].value || `rule ${index + 1}`;
+                }
+                return "";
+            } catch (e) {
+                return "";
+            }
+        },
+        icon: "font-awesome/fa-exchange",
+        paletteLabel: "enum switch",
+        label: function() {
+            const rules = JSON.parse(this.rules || "[]");
+            return this.name ? this.name : `enum switch (${rules.length} rules)`;
+        },
+        oneditprepare: function() {
+            const node = this;
+            const rulesContainer = $("#node-input-rules-list");
+            const template = $(".rule-template").clone().removeClass("rule-template").show();
+            
+            // Initialize typed inputs
+            $("#node-input-property").typedInput({
+                default: "msg",
+                types: ["msg", "flow", "global"],
+                typeField: "#node-input-propertyType"
+            }).typedInput("type", node.propertyType || "msg").typedInput("value", node.property);
+
+            // Parse existing rules
+            let rules = [];
+            try {
+                rules = JSON.parse(node.rules || "[]");
+            } catch (e) {
+                rules = [];
+            }
+            
+            // Render existing rules
+            rules.forEach(function(rule, index) {
+                const ruleItem = template.clone();
+                ruleItem.find(".node-input-rule-value").val(rule.value || "");
+                rulesContainer.append(ruleItem);
+            });
+            
+            // Add new rule button click
+            $("#node-input-add-rule").on("click", function() {
+                const ruleItem = template.clone();
+                rulesContainer.append(ruleItem);
+            });
+            
+            // Delete rule button click
+            rulesContainer.on("click", ".delete-rule", function() {
+                $(this).closest(".rule-item").remove();
+            });
+        },
+
+        oneditsave: function() {
+            const rules = [];
+            $("#node-input-rules-list .rule-item").each(function() {
+                const value = $(this).find(".node-input-rule-value").val().trim();
+                if (value) {
+                    rules.push({ value: value });
+                }
+            });
+            
+            $("#node-input-rules").val(JSON.stringify(rules));            
+            $("#node-input-outputs").val(rules.length);
+        },
+        oneditresize: function(size) {
+            $("#node-input-rules-container").height(size.height - 200);
+        }
+    });
+</script>
+
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="enum-switch-block">
+Route input to the appropriate output based on switch values.
+
+### Inputs
+: payload (string) : `string` for comparison.
+
+### Outputs
+: payload (boolean) : Boolean output based on matching switch value.
+
+### Properties
+: slots (integer) : Number of input slots (≥ 2).
+
+### Details
+Similar to the NodeRED switch node, but single purpose, with the important difference:
+1. Outputting boolean based on matching string input.
+2. Updating all outputs `true`/`false` on each input message. (updating false being the key difference)
+
+NodeRED `switch` node only outputs on matching cases, and does not update non-matching outputs unless you create opposing rules for each case, 
+which can be messy. Use case is to drive multiple boolean outputs based on a single string input, e.g., controlling visibility of multiple UI elements, 
+or routing logic based on a given mode.
+
+Supports string, number, and boolean comparisons. Input type is inferred from the incoming message payload type.
+
+Preserves original message structure, only modifying the payload to `true` or `false`.
+
+### 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/enum-switch-block.js

@@ -0,0 +1,101 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
+    function EnumSwitchBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Parse rules from config
+        let rules = [];
+        try {
+            rules = JSON.parse(config.rules || "[]");
+        } catch (e) {
+            node.error("Invalid rules configuration");
+            rules = [];
+        }
+        
+        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: "invalid message" });
+                if (done) done();
+                return;
+            }  
+
+            let matchAgainst;
+            
+            // Evaluate typed-input properties    
+            try {     
+                matchAgainst = RED.util.evaluateNodeProperty( config.property, config.propertyType, node, msg );
+
+                if (matchAgainst === undefined) {
+                    node.status({ fill: "red", shape: "ring", text: "property evaluation failed" });
+                    if (done) done();
+                    return;
+                }
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: `Error: ${err.message}` });
+                if (done) done(err);
+                return;
+            }
+
+            const outputs = [];
+            let matched = false;
+
+            // Evaluate each rule and set outputs
+            for (let i = 0; i < rules.length; i++) {
+                const rule = rules[i];
+                let match = false;
+
+                // Handle different types for comparison
+                if (matchAgainst === null || matchAgainst === undefined) {
+                    match = (rule.value === null || rule.value === undefined || rule.value === "");
+                } else if (typeof matchAgainst === 'string' && typeof rule.value === 'string') {
+                    match = matchAgainst === rule.value;
+                } else if (typeof matchAgainst === 'number') {
+                    const numericRuleValue = parseFloat(rule.value);
+                    match = !isNaN(numericRuleValue) && matchAgainst === numericRuleValue;
+                } else if (typeof matchAgainst === 'boolean') {
+                    const boolRuleValue = rule.value.toLowerCase() === 'true';
+                    match = matchAgainst === boolRuleValue;
+                } else {
+                    match = String(matchAgainst) === String(rule.value);
+                }
+
+                outputs[i] = match;
+                
+                if (match) {
+                    matched = true;
+                    node.status({ fill: "blue", shape: "dot", text: `Matched: ${rule.value}` });
+                }
+            }
+
+            // Send output messages (all outputs as booleans)
+            const messages = outputs.map(isMatch => {
+                return {
+                    ...msg,
+                    payload: isMatch,
+                    topic: msg.topic
+                };
+            });
+
+            send(messages);
+
+            if (!matched && rules.length > 0) {
+                node.status({ fill: "blue", shape: "ring", text: "No match" });
+            } else if (rules.length === 0) {
+                node.status({ fill: "yellow", shape: "ring", text: "No rules configured" });
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            if (done) done();
+        });
+    }
+    
+    RED.nodes.registerType("enum-switch-block", EnumSwitchBlockNode);
+};

package/nodes/hysteresis-block.html

@@ -94,7 +94,7 @@ Hysteresis controller with separate turn-on limits and turn-off differentials.
 
 ### Inputs
 : payload (number) : Input value to evaluate
-: context (string) : Configure `upperLimit`, `lowerLimit`, `upperLimitThreshold`, `lowerLimitThreshold`
+: context (string) : Configure `upperLimitThreshold`, `lowerLimitThreshold`
 
 ### Outputs
 : above (boolean) : Input > upperLimit