node-red-contrib-boolean-logic-ultimate 1.2.9 → 1.2.11

package/CHANGELOG.md

@@ -4,11 +4,24 @@
 
 # CHANGELOG
 
+<p>
+<b>Version 1.2.11</b> April 2026<br/>
+
+- DebouncerUltimate: simplified the node to a single output, with clearer editor labels for non-technical users.<br/>
+- Updated Debouncer help and README, adding a dedicated explanatory image.<br/>
+</p>
+
+<p>
+<b>Version 1.2.10</b> April 2026<br/>
+
+- NEW: DebouncerUltimate node for dedicated debounce flows with trailing/leading/both emission modes.<br/>
+- Updated README, examples and tests accordingly.<br/>
+</p>
+
 <p>
 <b>Version 1.2.9</b> April 2026<br/>
-- Removed the following newly introduced HA nodes because considered too complex: ForDurationUltimate, WatchdogUltimate, PriorityMuxUltimate, GroupStateUltimate.<br/>
-- Removed related examples, tests and documentation sections.<br/>
-- Kept HysteresisUltimate and aligned package registration/examples docs accordingly.<br/>
+
+- NEW: Hysteresis node and aligned package registration/examples docs accordingly.<br/>
 </p>
 
 <p>

package/README.md

@@ -1,17 +1,11 @@
 ![Logo](img/logo.png)
 
 [![NPM version][npm-version-image]][npm-url]
-
 [![NPM downloads per month][npm-downloads-month-image]][npm-url]
-
 [![NPM downloads total][npm-downloads-total-image]][npm-url]
-
 [![MIT License][license-image]][license-url]
-
 [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
-
 [![Donate via PayPal](https://img.shields.io/badge/Donate-PayPal-blue.svg?style=flat-square)](https://www.paypal.me/techtoday)
-
 [![youtube][youtube-image]][youtube-url]
 
 A set of Node-RED enhanced boolean logic and utility nodes, with persistent values after reboot. Compatible also with Homeassistant values.
@@ -662,7 +656,7 @@ Gateway per sensori e dispositivi troppo “chiacchieroni”: limita burst e rim
 | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Mode             | Seleziona la logica: _Debounce_ (attende quiete), _Throttle_ (impone un intervallo minimo), _Window_ (massimo N messaggi per finestra temporale). |
 | Wait (ms)        | Ritardo di quiete per la modalità debounce.                                                                                                       |
-| Emit             | Per debounce: scegli tra _Leading_ (subito), _Trailing_ (ultimo), _Both_.                                                                         |
+| Emit             | Per debounce: scegli se inviare subito il primo messaggio, solo l’ultimo dopo la pausa, oppure entrambi.                                          |
 | Interval (ms)    | Intervallo minimo tra messaggi in modalità throttle.                                                                                              |
 | Emit trailing    | In throttle, inoltra l’ultimo messaggio ricevuto allo scadere dell’intervallo.                                                                    |
 | Window size (ms) | Larghezza della finestra mobile in modalità window.                                                                                               |
@@ -691,6 +685,37 @@ Gateway per sensori e dispositivi troppo “chiacchieroni”: limita burst e rim
 
 <br/>
 
+# DEBOUNCER ULTIMATE
+
+Nodo dedicato al solo debounce: utile quando vuoi filtrare rimbalzi o burst rapidi senza portarti dietro le altre modalità del `RateLimiterUltimate`. Può inoltrare il **primo** messaggio, l’**ultimo** oppure **entrambi**, dopo un intervallo di quiete configurabile.
+
+<img src='img/debouncer.png' width='80%'>
+
+Nell'immagine si vede il comportamento tipico: a sinistra arrivano molti messaggi ravvicinati, il nodo aspetta una breve pausa, e a destra lascia passare solo il messaggio utile.
+
+Example flow: [`examples/DebouncerUltimate.json`](examples/DebouncerUltimate.json)
+
+### NODE CONFIGURATION
+
+| Property      | Description                                                                                   |
+| ------------- | --------------------------------------------------------------------------------------------- |
+| Wait (ms)     | Tempo di quiete richiesto prima di chiudere la finestra di debounce.                          |
+| Emit          | Scegli se inviare subito il primo messaggio, solo l’ultimo dopo la pausa, oppure entrambi.    |
+| Control topic | Topic dei messaggi di controllo (default `debouncer`).                                        |
+
+### OUTPUT
+
+- **Output 1**: messaggi inoltrati dopo il debounce.
+
+### CONTROL MESSAGES (`msg.topic === controlTopic`)
+
+- `msg.reset = true` &rarr; cancella timer e messaggio pendente.
+- `msg.flush = true` &rarr; inoltra subito l’ultimo messaggio in attesa.
+- `msg.wait` &rarr; aggiorna il ritardo di debounce a runtime.
+- `msg.emitOn = 'leading'|'trailing'|'both'` &rarr; cambia la modalità di emissione.
+
+<br/>
+
 # PRESENCE SIMULATOR ULTIMATE
 
 The purpose of this node is to replay a programmable sequence of messages in order to simulate occupancy when you are away.
@@ -758,16 +783,16 @@ Example flow: [`examples/HysteresisUltimate.json`](examples/HysteresisUltimate.j
 
 ### NODE CONFIGURATION
 
-| Property            | Description                                                                                                  |
-| ------------------- | ------------------------------------------------------------------------------------------------------------ |
-| Control topic       | Topic that receives runtime commands such as threshold updates and reset.                                   |
-| Mode                | `high` = ON above threshold, OFF below. `low` = ON below threshold, OFF above.                             |
-| ON/OFF threshold    | Hysteresis limits.                                                                                           |
-| Initial state       | Startup output state.                                                                                        |
-| Emit only on change | If enabled, output 1 emits only on state transitions.                                                       |
-| With Input          | Message property evaluated as numeric value (default `payload`).                                            |
-| Translator          | Optional translator-config.                                                                                  |
-| On/Off payload      | Typed payloads sent on output 1.                                                                            |
+| Property            | Description                                                                    |
+| ------------------- | ------------------------------------------------------------------------------ |
+| Control topic       | Topic that receives runtime commands such as threshold updates and reset.      |
+| Mode                | `high` = ON above threshold, OFF below. `low` = ON below threshold, OFF above. |
+| ON/OFF threshold    | Hysteresis limits.                                                             |
+| Initial state       | Startup output state.                                                          |
+| Emit only on change | If enabled, output 1 emits only on state transitions.                          |
+| With Input          | Message property evaluated as numeric value (default `payload`).               |
+| Translator          | Optional translator-config.                                                    |
+| On/Off payload      | Typed payloads sent on output 1.                                               |
 
 ### CONTROL MESSAGES (`msg.topic === controlTopic`)
 

package/boolean-logic-ultimate/DebouncerUltimate.html

@@ -0,0 +1,76 @@
+<script type="text/javascript">
+  RED.nodes.registerType('DebouncerUltimate', {
+    category: 'Boolean Logic Ultimate',
+    color: '#ff8080',
+    defaults: {
+      name: { value: '' },
+      wait: { value: 500, validate: RED.validators.number() },
+      emitOn: { value: 'trailing' },
+      controlTopic: { value: 'debouncer' }
+    },
+    inputs: 1,
+    outputs: 1,
+    outputLabels: ['Forward'],
+    icon: 'file-in.png',
+    label: function () {
+      return this.name || 'Debouncer';
+    },
+    paletteLabel: function () {
+      return 'Debouncer';
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="DebouncerUltimate">
+  <div class="form-row">
+    <b>Debouncer Ultimate</b>
+    &nbsp;&nbsp;<span style="color:red"><i class="fa fa-youtube-play"></i>&nbsp;<a target="_blank" href="https://youtu.be/t45kaMQzm5Q"><u>Youtube Video</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-wait"><i class="fa fa-hourglass-o"></i> Wait (ms)</label>
+    <input type="number" id="node-input-wait" min="0">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-emitOn"><i class="fa fa-exchange"></i> Emit</label>
+    <select id="node-input-emitOn">
+      <option value="leading">Send first message immediately</option>
+      <option value="trailing">Send only the last message after the pause</option>
+      <option value="both">Send first immediately and last after the pause</option>
+    </select>
+  </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>
+</script>
+
+<script type="text/markdown" data-help-name="DebouncerUltimate">
+<p>Dedicated debounce node to suppress rapid bursts and forward only the first, last or both messages of a quiet-time window.</p>
+
+<p><img src="/resources/node-red-contrib-boolean-logic-ultimate/img/debouncer.png" alt="Debouncer example" style="max-width:100%; border-radius:6px;" /></p>
+
+|Property|Description|
+|--|--|
+| Wait (ms) | Quiet time before the debounce window closes. |
+| Emit | Choose whether to send the first message immediately, only the last one after the pause, or both. |
+| Control topic | Topic used for runtime commands (default `debouncer`). |
+
+Output:
+
+- Output 1 forwards the debounced message.
+
+Control topic messages:
+
+- `msg.reset = true` clears the timer and pending message.
+- `msg.flush = true` emits the pending message immediately.
+- `msg.wait` updates the debounce time.
+- `msg.emitOn = 'leading'|'trailing'|'both'` changes the emission mode.
+</script>

package/boolean-logic-ultimate/DebouncerUltimate.js

@@ -0,0 +1,190 @@
+'use strict';
+
+module.exports = function (RED) {
+  function DebouncerUltimate(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const REDUtil = RED.util;
+    const helpers = require('./lib/node-helpers.js');
+
+    const setNodeStatus = helpers.createStatus(node);
+    const timerBag = helpers.createTimerBag(node);
+
+    const controlTopic = config.controlTopic || 'debouncer';
+
+    let wait = Number(config.wait);
+    if (!Number.isFinite(wait) || wait < 0) {
+      wait = 500;
+    }
+
+    let emitOn = normalizeEmitOn(config.emitOn);
+    let passedCount = 0;
+    let droppedCount = 0;
+    let currentState = 'idle';
+    let debounceTimer = null;
+    let leadingSent = false;
+    let pendingMessage = null;
+
+    function normalizeEmitOn(value) {
+      const normalized = String(value || 'trailing').toLowerCase();
+      return ['leading', 'trailing', 'both'].includes(normalized)
+        ? normalized
+        : 'trailing';
+    }
+
+    function clone(msg) {
+      return REDUtil.cloneMessage ? REDUtil.cloneMessage(msg) : JSON.parse(JSON.stringify(msg));
+    }
+
+    function sendStatus() {
+      const colour = currentState === 'idle' ? 'green' : 'yellow';
+      const modeLabel = {
+        leading: 'L',
+        trailing: 'T',
+        both: 'B',
+      }[emitOn] || 'T';
+
+      setNodeStatus({
+        fill: colour,
+        shape: 'dot',
+        text: `DB|${modeLabel}|${currentState} pass:${passedCount} drop:${droppedCount}`,
+      });
+    }
+
+    function emitForward(msg, nextState = 'idle') {
+      passedCount += 1;
+      currentState = nextState;
+      node.send(msg);
+      sendStatus();
+    }
+
+    function emitDrop() {
+      droppedCount += 1;
+      currentState = 'waiting';
+      sendStatus();
+    }
+
+    function clearDebounce() {
+      if (debounceTimer) {
+        timerBag.clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      pendingMessage = null;
+      leadingSent = false;
+    }
+
+    function resetDebounce() {
+      clearDebounce();
+      currentState = 'idle';
+      sendStatus();
+    }
+
+    function flushPending() {
+      if (!pendingMessage) {
+        currentState = 'idle';
+        sendStatus();
+        return false;
+      }
+
+      const toSend = pendingMessage;
+      if (debounceTimer) {
+        timerBag.clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      pendingMessage = null;
+      leadingSent = false;
+      emitForward(toSend, 'idle');
+      return true;
+    }
+
+    function handleControlMessage(msg) {
+      let consumed = false;
+
+      if (Object.prototype.hasOwnProperty.call(msg, 'wait')) {
+        const nextWait = Number(msg.wait);
+        if (Number.isFinite(nextWait) && nextWait >= 0) {
+          wait = nextWait;
+          consumed = true;
+        }
+      }
+
+      if (typeof msg.emitOn === 'string') {
+        emitOn = normalizeEmitOn(msg.emitOn);
+        consumed = true;
+      }
+
+      if (msg.reset === true) {
+        resetDebounce();
+        consumed = true;
+      }
+
+      if (msg.flush === true) {
+        flushPending();
+        consumed = true;
+      }
+
+      if (msg.status === true) {
+        consumed = true;
+        sendStatus();
+      }
+
+      if (consumed) {
+        sendStatus();
+      }
+
+      return consumed;
+    }
+
+    function handleDebounce(msg) {
+      const cloned = clone(msg);
+
+      if (debounceTimer) {
+        timerBag.clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+
+      pendingMessage = cloned;
+      currentState = 'waiting';
+
+      const shouldEmitLeading =
+        (emitOn === 'leading' || emitOn === 'both') && !leadingSent;
+
+      if (shouldEmitLeading) {
+        emitForward(cloned, 'waiting');
+        leadingSent = true;
+      }
+
+      if (emitOn === 'leading' && !shouldEmitLeading) {
+        emitDrop();
+      }
+
+      debounceTimer = timerBag.setTimeout(() => {
+        debounceTimer = null;
+        leadingSent = false;
+        const shouldEmitTrailing = emitOn === 'trailing' || emitOn === 'both';
+
+        if (shouldEmitTrailing && pendingMessage) {
+          const toSend = pendingMessage;
+          pendingMessage = null;
+          emitForward(toSend, 'idle');
+        } else {
+          pendingMessage = null;
+          currentState = 'idle';
+          sendStatus();
+        }
+      }, wait);
+    }
+
+    node.on('input', function (msg) {
+      if (msg.topic === controlTopic && handleControlMessage(msg)) {
+        return;
+      }
+
+      handleDebounce(msg);
+    });
+
+    sendStatus();
+  }
+
+  RED.nodes.registerType('DebouncerUltimate', DebouncerUltimate);
+};

package/boolean-logic-ultimate/RateLimiterUltimate.html

@@ -104,9 +104,9 @@
   <div class="form-row rate-config-section rate-config-debounce">
     <label for="node-input-emitOn"><i class="fa fa-exchange"></i> Emit</label>
     <select id="node-input-emitOn">
-      <option value="leading">Leading edge</option>
-      <option value="trailing">Trailing edge</option>
-      <option value="both">Both</option>
+      <option value="leading">Send first message immediately</option>
+      <option value="trailing">Send only the last message after the pause</option>
+      <option value="both">Send first immediately and last after the pause</option>
     </select>
   </div>
 
@@ -116,7 +116,7 @@
   </div>
 
   <div class="form-row rate-config-section rate-config-throttle">
-    <label for="node-input-trailing"><i class="fa fa-arrow-circle-right"></i> Emit trailing</label>
+    <label for="node-input-trailing"><i class="fa fa-arrow-circle-right"></i> Also send the last queued message</label>
     <input type="checkbox" id="node-input-trailing" style="width:auto; margin-top:7px;">
   </div>
 
@@ -144,8 +144,8 @@ The purpose of this node is to moderate the frequency of incoming messages.
 
 **Modes**
 
-- **Debounce** – waits for the line to be quiet before forwarding the final message. With *Leading* it emits the first message immediately and blocks the following ones until the delay ends; *Trailing* sends only the last message; *Both* combines both behaviours.
-- **Throttle** – enforces a minimum interval between consecutive messages. When *Emit trailing* is enabled the most recent message is forwarded once the interval has elapsed.
+- **Debounce** – waits for the line to be quiet before forwarding a message. You can choose to send the first message immediately, only the last message after the pause, or both.
+- **Throttle** – enforces a minimum interval between consecutive messages. When *Also send the last queued message* is enabled the most recent message is forwarded once the interval has elapsed.
 - **Window** – limits the number of messages in a moving time window. Extra messages can be dropped or queued to play once a slot becomes available.
 
 **Outputs**
@@ -161,4 +161,4 @@ The purpose of this node is to moderate the frequency of incoming messages.
 - `msg.interval`, `msg.wait`, `msg.windowSize`, `msg.maxInWindow` – adjust the related thresholds.
 
 The **With Input** field selects which message property to evaluate (default `msg.payload`). When configured, it can be translated through the **translator-config** node for Home Assistant compatibility.
-</script>
+</script>

package/examples/DebouncerUltimate.json

@@ -0,0 +1,168 @@
+[
+  {
+    "id": "db_tab_1",
+    "type": "tab",
+    "label": "DebouncerUltimate - burst filter",
+    "disabled": false,
+    "info": "Esempio: filtra burst ravvicinati con il nodo DebouncerUltimate."
+  },
+  {
+    "id": "db_cmt_1",
+    "type": "comment",
+    "z": "db_tab_1",
+    "name": "Burst → Debouncer → Forward",
+    "info": "Clicca BURST per generare messaggi ravvicinati. Cambia la modalità con LEADING/TRAILING/BOTH oppure usa FLUSH/RESET via topic \"debouncer\".",
+    "x": 300,
+    "y": 60,
+    "wires": []
+  },
+  {
+    "id": "db_inj_burst",
+    "type": "inject",
+    "z": "db_tab_1",
+    "name": "BURST (10 msgs)",
+    "props": [
+      { "p": "count", "v": "10", "vt": "num" },
+      { "p": "interval", "v": "50", "vt": "num" }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 150,
+    "y": 140,
+    "wires": [["db_fn_burst"]]
+  },
+  {
+    "id": "db_fn_burst",
+    "type": "function",
+    "z": "db_tab_1",
+    "name": "Burst generator",
+    "func": "const count = Number(msg.count || 10);\nconst interval = Number(msg.interval || 50);\nlet i = 0;\n\nconst sendOne = () => {\n  node.send({ topic: 'data', payload: i, index: i, ts: Date.now() });\n  i += 1;\n  if (i < count) {\n    setTimeout(sendOne, interval);\n  }\n};\n\nsendOne();\nreturn null;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 360,
+    "y": 140,
+    "wires": [["db_node_1"]]
+  },
+  {
+    "id": "db_inj_leading",
+    "type": "inject",
+    "z": "db_tab_1",
+    "name": "LEADING (400ms)",
+    "props": [
+      { "p": "topic", "v": "debouncer", "vt": "str" },
+      { "p": "emitOn", "v": "leading", "vt": "str" },
+      { "p": "wait", "v": "400", "vt": "num" }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 160,
+    "y": 220,
+    "wires": [["db_node_1"]]
+  },
+  {
+    "id": "db_inj_trailing",
+    "type": "inject",
+    "z": "db_tab_1",
+    "name": "TRAILING (400ms)",
+    "props": [
+      { "p": "topic", "v": "debouncer", "vt": "str" },
+      { "p": "emitOn", "v": "trailing", "vt": "str" },
+      { "p": "wait", "v": "400", "vt": "num" }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 170,
+    "y": 260,
+    "wires": [["db_node_1"]]
+  },
+  {
+    "id": "db_inj_both",
+    "type": "inject",
+    "z": "db_tab_1",
+    "name": "BOTH (400ms)",
+    "props": [
+      { "p": "topic", "v": "debouncer", "vt": "str" },
+      { "p": "emitOn", "v": "both", "vt": "str" },
+      { "p": "wait", "v": "400", "vt": "num" }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 150,
+    "y": 300,
+    "wires": [["db_node_1"]]
+  },
+  {
+    "id": "db_inj_flush",
+    "type": "inject",
+    "z": "db_tab_1",
+    "name": "FLUSH",
+    "props": [
+      { "p": "topic", "v": "debouncer", "vt": "str" },
+      { "p": "flush", "v": "true", "vt": "bool" }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 120,
+    "y": 340,
+    "wires": [["db_node_1"]]
+  },
+  {
+    "id": "db_inj_reset",
+    "type": "inject",
+    "z": "db_tab_1",
+    "name": "RESET",
+    "props": [
+      { "p": "topic", "v": "debouncer", "vt": "str" },
+      { "p": "reset", "v": "true", "vt": "bool" }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "x": 120,
+    "y": 380,
+    "wires": [["db_node_1"]]
+  },
+  {
+    "id": "db_node_1",
+    "type": "DebouncerUltimate",
+    "z": "db_tab_1",
+    "name": "Debouncer",
+    "wait": 400,
+    "emitOn": "trailing",
+    "controlTopic": "debouncer",
+    "x": 590,
+    "y": 240,
+    "wires": [["db_dbg_fwd"]]
+  },
+  {
+    "id": "db_dbg_fwd",
+    "type": "debug",
+    "z": "db_tab_1",
+    "name": "Forward",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "true",
+    "targetType": "full",
+    "statusVal": "",
+    "statusType": "auto",
+    "x": 780,
+    "y": 220,
+    "wires": []
+  }
+]

package/examples/README.md

@@ -11,6 +11,7 @@ How to import:
 - `BlinkerUltimate.json` — BlinkerUltimate
 - `BooleanLogicUltimate.json` — BooleanLogicUltimate
 - `Comparator.json` — Comparator
+- `DebouncerUltimate.json` — DebouncerUltimate
 - `FilterUltimate.json` — FilterUltimate
 - `HysteresisUltimate.json` — HysteresisUltimate
 - `ImpulseUltimate.json` — ImpulseUltimate

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "node-red-contrib-boolean-logic-ultimate",
-    "version": "1.2.9",
-    "description": "A set of Node-RED enhanced boolean logic and utility nodes, flow interruption, blinker, invert, filter, toggle etc.., with persistent values after reboot. Compatible also with Homeassistant values.",
+    "version": "1.2.11",
+    "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": {
         "fs": "0.0.1-security",
@@ -28,6 +28,7 @@
     },
     "node-red": {
         "nodes": {
+            "DebouncerUltimate": "boolean-logic-ultimate/DebouncerUltimate.js",
             "BooleanLogicUltimate": "boolean-logic-ultimate/BooleanLogicUltimate.js",
             "InvertUltimate": "boolean-logic-ultimate/InvertUltimate.js",
             "FilterUltimate": "boolean-logic-ultimate/FilterUltimate.js",

package/test/debouncer.spec.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const { expect } = require('chai');
+const { helper, loadDebouncer } = require('./helpers');
+
+describe('DebouncerUltimate node', function () {
+  this.timeout(5000);
+
+  before(function (done) {
+    helper.startServer(done);
+  });
+
+  after(function (done) {
+    helper.stopServer(done);
+  });
+
+  afterEach(function () {
+    return helper.unload();
+  });
+
+  it('trailing debounce emits only the last message after quiet time', function (done) {
+    const flowId = 'flow1';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'flow1' },
+      {
+        id: 'debouncer',
+        type: 'DebouncerUltimate',
+        z: flowId,
+        wait: 40,
+        emitOn: 'trailing',
+        controlTopic: 'debouncer',
+        wires: [['out']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['debouncer']] },
+      { id: 'out', type: 'helper', z: flowId },
+    ];
+
+    loadDebouncer(flow).then(() => {
+      const debouncer = helper.getNode('debouncer');
+      const out = helper.getNode('out');
+      const seen = [];
+
+      out.on('input', (msg) => {
+        seen.push(msg.payload);
+      });
+
+      debouncer.receive({ topic: 'sensor', payload: 'first' });
+      setTimeout(() => {
+        debouncer.receive({ topic: 'sensor', payload: 'second' });
+      }, 15);
+
+      setTimeout(() => {
+        try {
+          expect(seen).to.deep.equal(['second']);
+          done();
+        } catch (error) {
+          done(error);
+        }
+      }, 120);
+    }).catch(done);
+  });
+
+  it('both mode emits first immediately and last after quiet time', function (done) {
+    const flowId = 'flow2';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'flow2' },
+      {
+        id: 'debouncer',
+        type: 'DebouncerUltimate',
+        z: flowId,
+        wait: 50,
+        emitOn: 'both',
+        controlTopic: 'debouncer',
+        wires: [['out']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['debouncer']] },
+      { id: 'out', type: 'helper', z: flowId },
+    ];
+
+    loadDebouncer(flow).then(() => {
+      const debouncer = helper.getNode('debouncer');
+      const out = helper.getNode('out');
+      const seen = [];
+
+      out.on('input', (msg) => {
+        seen.push(msg.payload);
+      });
+
+      debouncer.receive({ topic: 'sensor', payload: 'first' });
+      setTimeout(() => {
+        debouncer.receive({ topic: 'sensor', payload: 'second' });
+      }, 15);
+
+      setTimeout(() => {
+        try {
+          expect(seen).to.deep.equal(['first', 'second']);
+          done();
+        } catch (error) {
+          done(error);
+        }
+      }, 140);
+    }).catch(done);
+  });
+
+  it('leading mode emits only the first message during the debounce window', function (done) {
+    const flowId = 'flow3';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'flow3' },
+      {
+        id: 'debouncer',
+        type: 'DebouncerUltimate',
+        z: flowId,
+        wait: 60,
+        emitOn: 'leading',
+        controlTopic: 'debouncer',
+        wires: [['out']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['debouncer']] },
+      { id: 'out', type: 'helper', z: flowId },
+    ];
+
+    loadDebouncer(flow).then(() => {
+      const debouncer = helper.getNode('debouncer');
+      const out = helper.getNode('out');
+      const seen = [];
+
+      out.on('input', (msg) => {
+        seen.push(msg.payload);
+      });
+
+      debouncer.receive({ topic: 'sensor', payload: 'first' });
+      setTimeout(() => {
+        debouncer.receive({ topic: 'sensor', payload: 'second' });
+      }, 15);
+
+      setTimeout(() => {
+        try {
+          expect(seen).to.deep.equal(['first']);
+          done();
+        } catch (error) {
+          done(error);
+        }
+      }, 140);
+    }).catch(done);
+  });
+});

package/test/helpers.js

@@ -6,6 +6,7 @@ const helper = require('node-red-node-test-helper');
 helper.init(require.resolve('node-red')); // initialise with Node-RED runtime
 
 const nodes = {
+  DebouncerUltimate: require(path.join('..', 'boolean-logic-ultimate', 'DebouncerUltimate.js')),
   RateLimiterUltimate: require(path.join('..', 'boolean-logic-ultimate', 'RateLimiterUltimate.js')),
   PresenceSimulatorUltimate: require(path.join('..', 'boolean-logic-ultimate', 'PresenceSimulatorUltimate.js')),
   RailwaySwitchUltimate: require(path.join('..', 'boolean-logic-ultimate', 'RailwaySwitchUltimate.js')),
@@ -33,6 +34,10 @@ function loadRateLimiter(flow, credentials = {}) {
   return loadNode(nodes.RateLimiterUltimate, flow, credentials);
 }
 
+function loadDebouncer(flow, credentials = {}) {
+  return loadNode(nodes.DebouncerUltimate, flow, credentials);
+}
+
 function loadPresence(flow, credentials = {}) {
   return loadNode(nodes.PresenceSimulatorUltimate, flow, credentials);
 }
@@ -43,6 +48,7 @@ function loadRailwaySwitch(flow, credentials = {}) {
 
 module.exports = {
   helper,
+  loadDebouncer,
   loadRateLimiter,
   loadPresence,
   loadRailwaySwitch,