node-red-contrib-boolean-logic-ultimate 1.1.27 → 1.2.1

package/boolean-logic-ultimate/StaircaseLightUltimate.js

@@ -0,0 +1,229 @@
+'use strict';
+
+module.exports = function (RED) {
+  const helpers = require('./lib/node-helpers.js');
+
+  function StaircaseLightUltimate(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const REDUtil = RED.util;
+
+    const setNodeStatus = helpers.createStatus(node);
+    const timerBag = helpers.createTimerBag(node);
+
+    const controlTopic = config.controlTopic || 'stairs';
+    const payloadPropName = config.payloadPropName || 'payload';
+
+    let translatorConfig = null;
+    if (config.translatorConfig) {
+      translatorConfig = RED.nodes.getNode(config.translatorConfig);
+    }
+
+    let durationMs = toMilliseconds(config.durationSeconds, 30);
+    let warningEnabled = Boolean(config.warningEnabled);
+    let warningOffsetMs = toMilliseconds(config.warningOffsetSeconds, 5);
+    const restartOnTrigger = config.restartOnTrigger !== false; // default true
+
+    let active = false;
+    let lightTimer = null;
+    let warningTimer = null;
+    let statusInterval = null;
+    let expiresAt = 0;
+    let lastTriggerMsg = null;
+    let cycleCount = 0;
+
+    function toMilliseconds(value, defaultSeconds) {
+      const seconds = Number(value);
+      if (Number.isFinite(seconds) && seconds > 0) {
+        return seconds * 1000;
+      }
+      return defaultSeconds * 1000;
+    }
+
+    function updateStatus(state) {
+      if (active) {
+        const remaining = Math.max(0, Math.round((expiresAt - Date.now()) / 1000));
+        setNodeStatus({
+          fill: 'green',
+          shape: 'dot',
+          text: `ON ${remaining}s (${cycleCount})`,
+        });
+      } else {
+        setNodeStatus({
+          fill: state === 'warning' ? 'yellow' : 'grey',
+          shape: state === 'warning' ? 'dot' : 'ring',
+          text: state === 'warning' ? 'Pre-off' : 'Idle',
+        });
+      }
+    }
+
+    function clearTimers() {
+      if (lightTimer) {
+        timerBag.clearTimeout(lightTimer);
+        lightTimer = null;
+      }
+      if (warningTimer) {
+        timerBag.clearTimeout(warningTimer);
+        warningTimer = null;
+      }
+      if (statusInterval) {
+        timerBag.clearInterval(statusInterval);
+        statusInterval = null;
+      }
+    }
+
+    function buildOutputMessage(type, value, baseMsg) {
+      const msg = baseMsg ? REDUtil.cloneMessage(baseMsg) : {};
+      try {
+        msg.payload = REDUtil.evaluateNodeProperty(value, type, node, baseMsg);
+      } catch (err) {
+        msg.payload = value;
+      }
+      return msg;
+    }
+
+    function sendMainOutput(on, baseMsg) {
+      const type = on ? config.onPayloadType || 'bool' : config.offPayloadType || 'bool';
+      const value = on ? config.onPayload : config.offPayload;
+      const msg = buildOutputMessage(type, value, baseMsg);
+      msg.event = on ? 'on' : 'off';
+      node.send([msg, null]);
+    }
+
+    function sendWarningOutput(baseMsg, remainingSeconds) {
+      const type = config.warningPayloadType || 'str';
+      const value = config.warningPayload || 'warning';
+      const msg = buildOutputMessage(type, value, baseMsg);
+      msg.event = 'warning';
+      msg.remaining = remainingSeconds;
+      node.send([null, msg]);
+      updateStatus('warning');
+    }
+
+    function scheduleStatusInterval() {
+      if (!statusInterval) {
+        statusInterval = timerBag.setInterval(() => {
+          if (!active) {
+            timerBag.clearInterval(statusInterval);
+            statusInterval = null;
+            return;
+          }
+          updateStatus();
+        }, 1000);
+      }
+    }
+
+    function forceOff() {
+      if (!active) {
+        updateStatus();
+        return;
+      }
+      clearTimers();
+      active = false;
+      cycleCount += 1;
+      sendMainOutput(false, lastTriggerMsg);
+      updateStatus();
+    }
+
+    function scheduleWarning() {
+      if (!warningEnabled) {
+        return;
+      }
+      const remainingMs = expiresAt - Date.now();
+      if (remainingMs <= warningOffsetMs) {
+        // Not enough time for warning
+        return;
+      }
+      warningTimer = timerBag.setTimeout(() => {
+        const remainingSeconds = Math.max(0, Math.round((expiresAt - Date.now()) / 1000));
+        sendWarningOutput(lastTriggerMsg, remainingSeconds);
+      }, remainingMs - warningOffsetMs);
+    }
+
+    function scheduleOff() {
+      clearTimers();
+      const now = Date.now();
+      expiresAt = now + durationMs;
+      lightTimer = timerBag.setTimeout(() => {
+        forceOff();
+      }, durationMs);
+      scheduleWarning();
+      scheduleStatusInterval();
+      updateStatus();
+    }
+
+    function activate(baseMsg) {
+      lastTriggerMsg = baseMsg ? REDUtil.cloneMessage(baseMsg) : lastTriggerMsg;
+      if (active) {
+        if (restartOnTrigger) {
+          scheduleOff();
+        }
+        return;
+      }
+      active = true;
+      sendMainOutput(true, baseMsg);
+      scheduleOff();
+    }
+
+    function handleControlMessage(msg) {
+      let consumed = false;
+      if (msg.command === 'start' || msg.command === 'on' || msg.start === true) {
+        activate(msg);
+        consumed = true;
+      }
+      if (msg.command === 'stop' || msg.command === 'off' || msg.stop === true) {
+        forceOff();
+        consumed = true;
+      }
+      if (msg.command === 'extend' || msg.extend === true) {
+        if (active) {
+          scheduleOff();
+        }
+        consumed = true;
+      }
+      if (msg.hasOwnProperty('duration')) {
+        durationMs = toMilliseconds(msg.duration, durationMs / 1000);
+        if (active) {
+          scheduleOff();
+        }
+        consumed = true;
+      }
+      if (msg.hasOwnProperty('warningEnabled')) {
+        warningEnabled = Boolean(msg.warningEnabled);
+        consumed = true;
+      }
+      if (msg.hasOwnProperty('warningOffset')) {
+        warningOffsetMs = toMilliseconds(msg.warningOffset, warningOffsetMs / 1000);
+        if (active) {
+          scheduleOff();
+        }
+        consumed = true;
+      }
+      return consumed;
+    }
+
+    node.on('input', (msg) => {
+      if (msg.topic === controlTopic) {
+        if (handleControlMessage(msg)) {
+          return;
+        }
+      }
+
+      const resolved = helpers.resolveInput(msg, payloadPropName, config.translatorConfig, RED);
+      const value = resolved.boolean;
+      if (value === true) {
+        activate(msg);
+      } else if (value === false && config.allowOffInput) {
+        forceOff();
+      }
+    });
+
+    node.on('close', () => {
+      clearTimers();
+    });
+
+    updateStatus();
+  }
+
+  RED.nodes.registerType('StaircaseLightUltimate', StaircaseLightUltimate);
+};

package/boolean-logic-ultimate/lib/node-helpers.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const utils = require('../utils.js');
+
+function createStatus(node) {
+  return function setNodeStatus({ fill, shape, text }) {
+    const dDate = new Date();
+    node.status({
+      fill,
+      shape,
+      text: `${text} (${dDate.getDate()}, ${dDate.toLocaleTimeString()})`,
+    });
+  };
+}
+
+function resolveInput(msg, propertyPath, translatorConfigId, RED) {
+  const propName = propertyPath || 'payload';
+  let value;
+  try {
+    value = utils.fetchFromObject(msg, propName);
+  } catch (error) {
+    return { value: undefined, boolean: undefined };
+  }
+  if (value === undefined) {
+    return { value: undefined, boolean: undefined };
+  }
+
+  const translatorConfig = translatorConfigId
+    ? RED.nodes.getNode(translatorConfigId)
+    : null;
+
+  return {
+    value,
+    boolean: utils.ToBoolean(value, translatorConfig),
+  };
+}
+
+function createTimerBag(node) {
+  const timers = new Set();
+  const intervals = new Set();
+
+  function trackTimeout(handle) {
+    timers.add(handle);
+    return handle;
+  }
+
+  function trackInterval(handle) {
+    intervals.add(handle);
+    return handle;
+  }
+
+  function clearAll() {
+    for (const handle of timers) {
+      clearTimeout(handle);
+    }
+    timers.clear();
+    for (const handle of intervals) {
+      clearInterval(handle);
+    }
+    intervals.clear();
+  }
+
+  node.on('close', (_removed, done) => {
+    clearAll();
+    done();
+  });
+
+  return {
+    setTimeout(fn, timeout) {
+      const handle = setTimeout(() => {
+        timers.delete(handle);
+        fn();
+      }, timeout);
+      return trackTimeout(handle);
+    },
+    setInterval(fn, interval) {
+      const handle = setInterval(fn, interval);
+      return trackInterval(handle);
+    },
+    clearTimeout(handle) {
+      clearTimeout(handle);
+      timers.delete(handle);
+    },
+    clearInterval(handle) {
+      clearInterval(handle);
+      intervals.delete(handle);
+    },
+    clearAll,
+  };
+}
+
+module.exports = {
+  createStatus,
+  resolveInput,
+  createTimerBag,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-boolean-logic-ultimate",
-    "version": "1.1.27",
+    "version": "1.2.1",
     "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.",
     "author": "Supergiovane (https://github.com/Supergiovane)",
     "dependencies": {
@@ -8,6 +8,12 @@
         "path": ">=0.12.7",
         "kalmanjs": "1.1.0"
     },
+    "devDependencies": {
+        "chai": "^4.3.10",
+        "mocha": "^10.4.0",
+        "node-red": "^3.1.0",
+        "node-red-node-test-helper": "^0.3.5"
+    },
     "keywords": [
         "node-red",
         "boolean",
@@ -36,7 +42,13 @@
             "RailwaySwitchUltimate": "boolean-logic-ultimate/RailwaySwitchUltimate.js",
             "Comparator": "boolean-logic-ultimate/Comparator.js",
             "KalmanFilterUltimate": "boolean-logic-ultimate/KalmanFilterUltimate.js",
+            "RateLimiterUltimate": "boolean-logic-ultimate/RateLimiterUltimate.js",
+            "PresenceSimulatorUltimate": "boolean-logic-ultimate/PresenceSimulatorUltimate.js",
+            "StaircaseLightUltimate": "boolean-logic-ultimate/StaircaseLightUltimate.js",
             "translator-config": "boolean-logic-ultimate/translator-config.js"
         }
+    },
+    "scripts": {
+        "test": "mocha test/**/*.spec.js"
     }
 }

package/test/helpers.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const path = require('path');
+const helper = require('node-red-node-test-helper');
+
+helper.init(require.resolve('node-red')); // initialise with Node-RED runtime
+
+const nodes = {
+  RateLimiterUltimate: require(path.join('..', 'boolean-logic-ultimate', 'RateLimiterUltimate.js')),
+  PresenceSimulatorUltimate: require(path.join('..', 'boolean-logic-ultimate', 'PresenceSimulatorUltimate.js')),
+};
+
+function loadNode(nodeDef, flow, credentials = {}) {
+  return helper.load(nodeDef, flow, credentials);
+}
+
+function loadRateLimiter(flow, credentials = {}) {
+  return loadNode(nodes.RateLimiterUltimate, flow, credentials);
+}
+
+function loadPresence(flow, credentials = {}) {
+  return loadNode(nodes.PresenceSimulatorUltimate, flow, credentials);
+}
+
+module.exports = {
+  helper,
+  loadRateLimiter,
+  loadPresence,
+};

package/test/presence-simulator.spec.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { expect } = require('chai');
+const { helper, loadPresence } = require('./helpers');
+
+describe('PresenceSimulatorUltimate node', function () {
+  this.timeout(5000);
+
+  before(function (done) {
+    helper.startServer(done);
+  });
+
+  after(function (done) {
+    helper.stopServer(done);
+  });
+
+  afterEach(function () {
+    return helper.unload();
+  });
+
+  it('plays sequence after start command', function (done) {
+    const flowId = 'flowPresence1';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'presence1' },
+      {
+        id: 'presence',
+        type: 'PresenceSimulatorUltimate',
+        z: flowId,
+        name: '',
+        controlTopic: 'presence',
+        autoStart: false,
+        autoLoop: false,
+        randomize: false,
+        patterns: '{"delay":20,"payload":true,"topic":"light"}',
+        wires: [['out']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['presence']] },
+      { id: 'out', type: 'helper', z: flowId },
+    ];
+
+    loadPresence(flow).then(() => {
+      const input = helper.getNode('in');
+      const out = helper.getNode('out');
+
+      out.on('input', (msg) => {
+        try {
+          expect(msg).to.have.property('payload', true);
+          expect(msg).to.have.property('topic', 'light');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      input.receive({ topic: 'presence', command: 'start' });
+    }).catch(done);
+  });
+
+  it('stops sequence on stop command', function (done) {
+    const flowId = 'flowPresence2';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'presence2' },
+      {
+        id: 'presence',
+        type: 'PresenceSimulatorUltimate',
+        z: flowId,
+        controlTopic: 'presence',
+        autoStart: false,
+        autoLoop: true,
+        randomize: false,
+        patterns: '{"delay":20,"payload":"on","topic":"light"}',
+        wires: [['out']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['presence']] },
+      { id: 'out', type: 'helper', z: flowId },
+    ];
+
+    loadPresence(flow).then(() => {
+      const input = helper.getNode('in');
+      const out = helper.getNode('out');
+      let received = 0;
+
+      out.on('input', () => {
+        received += 1;
+        if (received === 1) {
+          input.receive({ topic: 'presence', command: 'stop' });
+          setTimeout(() => {
+            try {
+              expect(received).to.equal(1);
+              done();
+            } catch (err) {
+              done(err);
+            }
+          }, 100);
+        }
+      });
+
+      input.receive({ topic: 'presence', command: 'start' });
+    }).catch(done);
+  });
+});

package/test/rate-limiter.spec.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const { expect } = require('chai');
+const { helper, loadRateLimiter } = require('./helpers');
+
+describe('RateLimiterUltimate node', function () {
+  this.timeout(5000);
+
+  before(function (done) {
+    helper.startServer(done);
+  });
+
+  after(function (done) {
+    helper.stopServer(done);
+  });
+
+  afterEach(function () {
+    return helper.unload();
+  });
+
+  it('debounce trailing emits after wait', function (done) {
+    const flowId = 'flow1';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'flow1' },
+      {
+        id: 'rate',
+        type: 'RateLimiterUltimate',
+        z: flowId,
+        name: 'debounce-test',
+        mode: 'debounce',
+        wait: 40,
+        emitOn: 'trailing',
+        payloadPropName: 'payload',
+        controlTopic: 'rate',
+        statInterval: 0,
+        wires: [['out'], ['diag']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['rate']] },
+      { id: 'out', type: 'helper', z: flowId },
+      { id: 'diag', type: 'helper', z: flowId },
+    ];
+
+    loadRateLimiter(flow).then(() => {
+      const input = helper.getNode('in');
+      const out = helper.getNode('out');
+      const diag = helper.getNode('diag');
+
+      diag.on('input', () => done(new Error('Should not emit diagnostics for trailing debounce')));
+
+      out.on('input', (msg) => {
+        try {
+          expect(msg.payload).to.equal('first');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      input.receive({ topic: 'sensor', payload: 'first' });
+    }).catch(done);
+  });
+
+  it('throttle drops rapid message when trailing disabled', function (done) {
+    const flowId = 'flow2';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'flow2' },
+      {
+        id: 'rate',
+        type: 'RateLimiterUltimate',
+        z: flowId,
+        name: 'throttle-test',
+        mode: 'throttle',
+        interval: 120,
+        trailing: false,
+        payloadPropName: 'payload',
+        controlTopic: 'rate',
+        statInterval: 0,
+        wires: [['out'], ['diag']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['rate']] },
+      { id: 'out', type: 'helper', z: flowId },
+      { id: 'diag', type: 'helper', z: flowId },
+    ];
+
+    loadRateLimiter(flow).then(() => {
+      const input = helper.getNode('in');
+      const out = helper.getNode('out');
+      const diag = helper.getNode('diag');
+      let seenForward = 0;
+
+      out.on('input', (msg) => {
+        seenForward += 1;
+        if (seenForward > 1) {
+          done(new Error('Unexpected second forward message'));
+        } else {
+          expect(msg.payload).to.equal('first');
+        }
+      });
+
+      diag.on('input', (msg) => {
+        try {
+          expect(msg.payload).to.have.property('reason', 'dropped-throttle');
+          expect(msg.payload.msg.payload).to.equal('second');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      input.receive({ topic: 'sensor', payload: 'first' });
+      setTimeout(() => {
+        input.receive({ topic: 'sensor', payload: 'second' });
+      }, 20);
+    }).catch(done);
+  });
+
+  it('window queue replays message after window expires', function (done) {
+    const flowId = 'flow3';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'flow3' },
+      {
+        id: 'rate',
+        type: 'RateLimiterUltimate',
+        z: flowId,
+        name: 'window-test',
+        mode: 'window',
+        windowSize: 120,
+        maxInWindow: 1,
+        dropStrategy: 'queue',
+        payloadPropName: 'payload',
+        controlTopic: 'rate',
+        statInterval: 0,
+        wires: [['out'], ['diag']],
+      },
+      { id: 'in', type: 'helper', z: flowId, wires: [['rate']] },
+      { id: 'out', type: 'helper', z: flowId },
+      { id: 'diag', type: 'helper', z: flowId },
+    ];
+
+    loadRateLimiter(flow).then(() => {
+      const input = helper.getNode('in');
+      const out = helper.getNode('out');
+      const diag = helper.getNode('diag');
+      const start = Date.now();
+      const outputs = [];
+
+      diag.on('input', () => done(new Error('Queue strategy should not drop messages')));
+
+      out.on('input', (msg) => {
+        outputs.push({ msg, ts: Date.now() - start });
+        if (outputs.length === 2) {
+          try {
+            expect(outputs[0].msg.payload).to.equal('one');
+            expect(outputs[1].msg.payload).to.equal('two');
+            expect(outputs[1].ts).to.be.at.least(100);
+            done();
+          } catch (err) {
+            done(err);
+          }
+        }
+      });
+
+      input.receive({ topic: 'sensor', payload: 'one' });
+      setTimeout(() => {
+        input.receive({ topic: 'sensor', payload: 'two' });
+      }, 20);
+    }).catch(done);
+  });
+});