node-red-contrib-boolean-logic-ultimate 1.2.13 → 1.2.14

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 # CHANGELOG
 
+<p>
+<b>Version 1.2.14</b> June 2026<br/>
+
+- NEW: MinMaxLimiterUltimate node, constrains a numeric value between a min and a max (clamp/saturation), e.g. to keep a dimmable lamp away from its extreme values.<br/>
+- Replaced all node icons with native Node-RED icons for consistent, properly centered rendering.<br/>
+</p>
+
 <p>
 <b>Version 1.2.13</b> May 2026<br/>
 

package/boolean-logic-ultimate/BlinkerUltimate.html

@@ -24,7 +24,7 @@
 					break;
 			}
 		},
-		icon: "light.png",
+		icon: "light.svg",
 		label:
 			function () {
 				return (this.name || "Blinker") + " (" + this.blinkfrequency + "ms)";

package/boolean-logic-ultimate/BooleanLogicUltimate.html

@@ -56,7 +56,7 @@
 					break;
 			}
 		},
-		icon: "serial.png",
+		icon: "serial.svg",
 		label:
 			function () {
 				let label = "";

package/boolean-logic-ultimate/Comparator.html

@@ -21,7 +21,7 @@
         },
         inputs: 1,
         outputs: 1,
-        icon: "font-awesome/fa-arrows-v",
+        icon: "sort.svg",
         label:
             function () {
                 return this.name || "Comparator";

package/boolean-logic-ultimate/DebouncerUltimate.html

@@ -11,7 +11,7 @@
     inputs: 1,
     outputs: 1,
     outputLabels: ['Forward'],
-    icon: 'file-in.png',
+    icon: 'file-in.svg',
     label: function () {
       return this.name || 'Debouncer';
     },

package/boolean-logic-ultimate/FilterUltimate.html

@@ -24,7 +24,7 @@
 					break;
 			}
 		},
-		icon: "switch.png",
+		icon: "switch.svg",
 		label:
 			function () {
 				return this.name || "Filter";

package/boolean-logic-ultimate/HysteresisUltimate.html

@@ -20,7 +20,7 @@
     inputs: 1,
     outputs: 2,
     outputLabels: ['State output', 'Diagnostics'],
-    icon: 'font-awesome/fa-sliders',
+    icon: 'rbe.svg',
     label: function () {
       return this.name || 'Hysteresis';
     },
@@ -134,4 +134,4 @@ Control topic messages:
 - `msg.state = true|false` to force state.
 - `msg.reset = true` to restore initial state.
 - `msg.status = true` to emit current status on output 2.
-</script>
+</script>

package/boolean-logic-ultimate/InterruptFlowUltimate.html

@@ -25,7 +25,7 @@
 					break;
 			}
 		},
-		icon: "file-in.png",
+		icon: "file-in.svg",
 		label:
 			function () {
 				return (this.name || "Interrupt") + " (" + this.triggertopic + ")";

package/boolean-logic-ultimate/InvertUltimate.html

@@ -11,7 +11,7 @@
 		},
 		inputs: 1,
 		outputs: 1,
-		icon: "swap.png",
+		icon: "swap.svg",
 		label:
 			function () {
 				return this.name || "Invert";

package/boolean-logic-ultimate/KalmanFilterUltimate.html

@@ -13,7 +13,7 @@
 		},
 		inputs: 1,
 		outputs: 1,
-		icon: "swap.png",
+		icon: "swap.svg",
 		label:
 			function () {
 				return this.name || "KalmanFilter";

package/boolean-logic-ultimate/MinMaxLimiterUltimate.html

@@ -0,0 +1,100 @@
+<script type="text/javascript">
+  RED.nodes.registerType('MinMaxLimiterUltimate', {
+    category: 'Boolean Logic Ultimate',
+    color: '#ff8080',
+    defaults: {
+      name: { value: '' },
+      controlTopic: { value: 'clamp' },
+      payloadPropName: { value: 'payload', required: false },
+      translatorConfig: { type: 'translator-config', required: false },
+      min: { value: 10, validate: RED.validators.number() },
+      max: { value: 90, validate: RED.validators.number() },
+      passInvalid: { value: false }
+    },
+    inputs: 1,
+    outputs: 1,
+    outputLabels: ['Clamped value'],
+    icon: 'range.svg',
+    label: function () {
+      return this.name || 'Min-Max Limiter';
+    },
+    paletteLabel: function () {
+      return 'Min-Max Limiter';
+    },
+    oneditprepare: function () {
+      const payloadField = $('#node-input-payloadPropName');
+      if (payloadField.val() === '') payloadField.val('payload');
+      payloadField.typedInput({ default: 'msg', types: ['msg'] });
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="MinMaxLimiterUltimate">
+  <div class="form-row">
+    <b>Min-Max Limiter</b>
+    &nbsp;&nbsp;<span style="color:red"><i class="fa fa-question-circle"></i>&nbsp;<a target="_blank" href="https://github.com/Supergiovane/node-red-contrib-boolean-logic-ultimate"><u>Help online</u></a></span>
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-name"><i class="icon-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-controlTopic"><i class="fa fa-tag"></i> Control topic</label>
+    <input type="text" id="node-input-controlTopic">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-min"><i class="fa fa-long-arrow-down"></i> Min (lower limit)</label>
+    <input type="number" id="node-input-min" step="any">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-max"><i class="fa fa-long-arrow-up"></i> Max (upper limit)</label>
+    <input type="number" id="node-input-max" step="any">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-passInvalid"><i class="fa fa-share"></i> Pass non-numbers</label>
+    <input type="checkbox" id="node-input-passInvalid" style="width:auto; margin-top:7px;">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-payloadPropName"><i class="fa fa-ellipsis-h"></i> Input</label>
+    <input type="text" id="node-input-payloadPropName">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-translatorConfig"><i class="fa fa-language"></i> Translator</label>
+    <input type="text" id="node-input-translatorConfig">
+  </div>
+</script>
+
+<script type="text/markdown" data-help-name="MinMaxLimiterUltimate">
+<p>Constrains a numeric value between a lower and an upper limit (clamp / saturation).
+Useful, for example, to keep a dimmable lamp away from its extreme values.</p>
+
+<p>If the input is below <code>Min</code> it outputs <code>Min</code>; if it is above
+<code>Max</code> it outputs <code>Max</code>; otherwise the value passes through unchanged.</p>
+
+|Property|Description|
+|--|--|
+| Control topic | Topic used to update limits at runtime. |
+| Min | Lower limit. Values below it are raised to this value. |
+| Max | Upper limit. Values above it are lowered to this value. |
+| Pass non-numbers | If enabled, non-numeric inputs are forwarded unchanged instead of being dropped. |
+| Input | Message property to read and write (default `payload`). |
+| Translator | Optional translator-config. |
+
+<p>The output message also carries <code>msg.clamp</code> with
+<code>{ clamped, input, output, min, max }</code>.</p>
+
+<p>Example (Min=10, Max=90): input <code>0</code> &rarr; <code>10</code>,
+input <code>50</code> &rarr; <code>50</code>, input <code>100</code> &rarr; <code>90</code>.</p>
+
+Control topic messages:
+
+- `msg.min` to update the lower limit at runtime.
+- `msg.max` to update the upper limit at runtime.
+</script>

package/boolean-logic-ultimate/MinMaxLimiterUltimate.js

@@ -0,0 +1,128 @@
+'use strict';
+
+module.exports = function (RED) {
+  const helpers = require('./lib/node-helpers.js');
+
+  function MinMaxLimiterUltimate(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const REDUtil = RED.util;
+
+    const setNodeStatus = helpers.createStatus(node);
+
+    const controlTopic = config.controlTopic || 'clamp';
+    const payloadPropName = config.payloadPropName || 'payload';
+    const passInvalid = config.passInvalid === true;
+
+    let min = Number(config.min);
+    let max = Number(config.max);
+
+    if (!Number.isFinite(min)) min = 10;
+    if (!Number.isFinite(max)) max = 90;
+
+    function normalizeLimits() {
+      // Keep min <= max even if the user (or a control message) swaps them.
+      if (Number.isFinite(min) && Number.isFinite(max) && min > max) {
+        const tmp = min;
+        min = max;
+        max = tmp;
+      }
+    }
+
+    function toNumber(value) {
+      if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+      }
+      if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+      }
+      if (typeof value === 'string') {
+        const v = Number(value.trim());
+        return Number.isFinite(v) ? v : undefined;
+      }
+      return undefined;
+    }
+
+    function updateStatus(lastValue, clamped) {
+      let text;
+      if (lastValue === undefined) {
+        text = `min:${min} max:${max}`;
+      } else {
+        const valueText = Number(lastValue).toFixed(2).replace(/\.00$/, '');
+        text = `${valueText} [${min}..${max}]`;
+      }
+      setNodeStatus({
+        fill: clamped ? 'yellow' : 'green',
+        shape: clamped ? 'ring' : 'dot',
+        text,
+      });
+    }
+
+    function handleControl(msg) {
+      let consumed = false;
+
+      if (Object.prototype.hasOwnProperty.call(msg, 'min')) {
+        const next = Number(msg.min);
+        if (Number.isFinite(next)) {
+          min = next;
+          consumed = true;
+        }
+      }
+
+      if (Object.prototype.hasOwnProperty.call(msg, 'max')) {
+        const next = Number(msg.max);
+        if (Number.isFinite(next)) {
+          max = next;
+          consumed = true;
+        }
+      }
+
+      if (consumed) {
+        normalizeLimits();
+        updateStatus();
+      }
+
+      return consumed;
+    }
+
+    node.on('input', (msg) => {
+      if (msg.topic === controlTopic && handleControl(msg)) {
+        return;
+      }
+
+      const resolved = helpers.resolveInput(msg, payloadPropName, config.translatorConfig, RED);
+      const inputValue = toNumber(resolved.value);
+
+      if (inputValue === undefined) {
+        node.warn(`MinMaxLimiterUltimate: '${payloadPropName}' is not a number (${resolved.value})`);
+        updateStatus();
+        if (passInvalid) {
+          node.send(msg);
+        }
+        return;
+      }
+
+      let outputValue = inputValue;
+      if (outputValue < min) outputValue = min;
+      if (outputValue > max) outputValue = max;
+      const clamped = outputValue !== inputValue;
+
+      REDUtil.setMessageProperty(msg, payloadPropName, outputValue, true);
+      msg.clamp = {
+        clamped,
+        input: inputValue,
+        output: outputValue,
+        min,
+        max,
+      };
+
+      node.send(msg);
+      updateStatus(inputValue, clamped);
+    });
+
+    normalizeLimits();
+    updateStatus();
+  }
+
+  RED.nodes.registerType('MinMaxLimiterUltimate', MinMaxLimiterUltimate);
+};

package/boolean-logic-ultimate/PresenceSimulatorUltimate.html

@@ -15,7 +15,7 @@
     },
     inputs: 1,
     outputs: 1,
-    icon: 'file-in.png',
+    icon: 'file-in.svg',
     label: function () {
       return this.name || 'Presence Simulator';
     },

package/boolean-logic-ultimate/RailwaySwitchUltimate.html

@@ -16,7 +16,7 @@
 		outputLabels: function (i) {
 			return "PIN " + i;
 		},
-		icon: "font-awesome/fa-train",
+		icon: "switch.svg",
 		label:
 			function () {
 				return (this.name || "Switch") + " (" + this.triggertopic + ")";

package/boolean-logic-ultimate/RateLimiterUltimate.html

@@ -22,7 +22,7 @@
     outputLabels: function (index) {
       return index === 0 ? 'Forward' : 'Diagnostics';
     },
-    icon: 'file-in.png',
+    icon: 'file-in.svg',
     label: function () {
       const mode = (this.mode || 'debounce').charAt(0).toUpperCase() + (this.mode || 'debounce').slice(1);
       return (this.name || 'RateLimiter') + ' (' + mode + ')';

package/boolean-logic-ultimate/SimpleOutputUltimate.html

@@ -22,7 +22,7 @@
                     break;
             }
         },
-        icon: "font-awesome/fa-arrow-circle-o-right",
+        icon: "arrow-in.svg",
         label:
             function () {
                 return this.name || "Simple Output";

package/boolean-logic-ultimate/StaircaseLightUltimate.html

@@ -22,7 +22,7 @@
     inputs: 1,
     outputs: 2,
     outputLabels: ['Light command', 'Warning'],
-    icon: 'timer.png',
+    icon: 'timer.svg',
     label: function () {
       return this.name || 'Staircase Light';
     },

package/boolean-logic-ultimate/StatusUltimate.html

@@ -13,7 +13,7 @@
         },
         inputs: 1,
         outputs: 1,
-        icon: "font-awesome/fa-eye",
+        icon: "white-globe.svg",
         label:
             function () {
                 return this.name || "Status";

package/boolean-logic-ultimate/SumUltimate.html

@@ -16,7 +16,7 @@
         },
         inputs: 1,
         outputs: 1,
-        icon: "font-awesome/fa-plus",
+        icon: "hash.svg",
         label:
             function () {
                 return this.name || "Math";

package/boolean-logic-ultimate/toggleUltimate.html

@@ -12,7 +12,7 @@
 		},
 		inputs: 1,
 		outputs: 1,
-		icon: "serial.png",
+		icon: "serial.svg",
 		label:
 			function () {
 				return this.name || "Toggle";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-boolean-logic-ultimate",
-    "version": "1.2.13",
+    "version": "1.2.14",
     "description": "A set of Node-RED enhanced boolean logic and utility nodes, flow interruption, blinker, debouncer, invert, filter, toggle etc.., with persistent values after reboot. Compatible also with Homeassistant values.",
     "author": "Supergiovane (https://github.com/Supergiovane)",
     "dependencies": {
@@ -47,6 +47,7 @@
             "PresenceSimulatorUltimate": "boolean-logic-ultimate/PresenceSimulatorUltimate.js",
             "StaircaseLightUltimate": "boolean-logic-ultimate/StaircaseLightUltimate.js",
             "HysteresisUltimate": "boolean-logic-ultimate/HysteresisUltimate.js",
+            "MinMaxLimiterUltimate": "boolean-logic-ultimate/MinMaxLimiterUltimate.js",
             "translator-config": "boolean-logic-ultimate/translator-config.js"
         }
     },

package/test/min-max-limiter.spec.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const { expect } = require('chai');
+const { helper } = require('./helpers');
+
+const clampNode = require('../boolean-logic-ultimate/MinMaxLimiterUltimate.js');
+
+function loadClamp(flow, credentials) {
+  const normalizedFlow = flow.map((node, index) => {
+    if (
+      node &&
+      node.type &&
+      node.type !== 'tab' &&
+      node.type !== 'subflow' &&
+      node.type !== 'group' &&
+      node.z &&
+      !(Object.prototype.hasOwnProperty.call(node, 'x') && Object.prototype.hasOwnProperty.call(node, 'y'))
+    ) {
+      return { ...node, x: 100 + index * 10, y: 100 + index * 10 };
+    }
+    return node;
+  });
+  return helper.load(clampNode, normalizedFlow, credentials || {});
+}
+
+describe('MinMaxLimiterUltimate node', function () {
+  this.timeout(5000);
+
+  before(function (done) {
+    helper.startServer(done);
+  });
+
+  after(function (done) {
+    helper.stopServer(done);
+  });
+
+  afterEach(function () {
+    return helper.unload();
+  });
+
+  function baseFlow(extra) {
+    const flowId = 'clamp1';
+    return [
+      { id: flowId, type: 'tab', label: 'clamp1' },
+      Object.assign(
+        {
+          id: 'clamp',
+          type: 'MinMaxLimiterUltimate',
+          z: flowId,
+          min: 10,
+          max: 90,
+          payloadPropName: 'payload',
+          wires: [['out']],
+        },
+        extra || {}
+      ),
+      { id: 'in', type: 'helper', z: flowId, wires: [['clamp']] },
+      { id: 'out', type: 'helper', z: flowId },
+    ];
+  }
+
+  it('clamps below min, above max and passes through in range', function (done) {
+    loadClamp(baseFlow()).then(() => {
+      const clamp = helper.getNode('clamp');
+      const out = helper.getNode('out');
+      const results = [];
+
+      out.on('input', (msg) => {
+        results.push(msg.payload);
+        if (results.length === 3) {
+          try {
+            expect(results).to.deep.equal([10, 50, 90]);
+            done();
+          } catch (error) {
+            done(error);
+          }
+        }
+      });
+
+      clamp.receive({ payload: 0 });
+      clamp.receive({ payload: 50 });
+      clamp.receive({ payload: 100 });
+    }).catch(done);
+  });
+
+  it('exposes msg.clamp diagnostics', function (done) {
+    loadClamp(baseFlow()).then(() => {
+      const clamp = helper.getNode('clamp');
+      const out = helper.getNode('out');
+
+      out.on('input', (msg) => {
+        try {
+          expect(msg.clamp).to.deep.equal({
+            clamped: true,
+            input: 5,
+            output: 10,
+            min: 10,
+            max: 90,
+          });
+          done();
+        } catch (error) {
+          done(error);
+        }
+      });
+
+      clamp.receive({ payload: 5 });
+    }).catch(done);
+  });
+
+  it('updates limits at runtime via control topic', function (done) {
+    loadClamp(baseFlow({ controlTopic: 'clamp' })).then(() => {
+      const clamp = helper.getNode('clamp');
+      const out = helper.getNode('out');
+
+      out.on('input', (msg) => {
+        try {
+          expect(msg.payload).to.equal(20);
+          done();
+        } catch (error) {
+          done(error);
+        }
+      });
+
+      clamp.receive({ topic: 'clamp', min: 20, max: 80 });
+      clamp.receive({ payload: 5 });
+    }).catch(done);
+  });
+});