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

package/boolean-logic-ultimate/RateLimiterUltimate.js

@@ -0,0 +1,396 @@
+'use strict';
+
+module.exports = function (RED) {
+  function RateLimiterUltimate(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const REDUtil = RED.util;
+    const helpers = require('./lib/node-helpers.js');
+
+    const {
+      mode: initialMode = 'debounce',
+      wait = 500,
+      emitOn = 'trailing',
+      interval = 1000,
+      trailing = false,
+      windowSize = 1000,
+      maxInWindow = 10,
+      dropStrategy = 'drop',
+      payloadPropName = 'payload',
+      translatorConfig,
+      controlTopic = 'rate',
+      statInterval = 0,
+    } = config;
+
+    let currentMode = initialMode;
+    let passedCount = 0;
+    let droppedCount = 0;
+    let currentState = 'idle';
+
+    const setNodeStatus = helpers.createStatus(node);
+    const timerBag = helpers.createTimerBag(node);
+
+    const modeLabels = {
+      debounce: 'DB',
+      throttle: 'TH',
+      window: 'WN',
+    };
+
+    const stateLabels = {
+      idle: 'idle',
+      waiting: 'waiting',
+      cooldown: 'cooldown',
+      blocked: 'blocked',
+    };
+
+    function sendStatus() {
+      const prefix = modeLabels[currentMode] || currentMode.toUpperCase();
+      const state = stateLabels[currentState] || currentState;
+      const colour = currentState === 'idle' ? 'green' : currentState === 'waiting' || currentState === 'cooldown' ? 'yellow' : 'red';
+      setNodeStatus({
+        fill: colour,
+        shape: 'dot',
+        text: `${prefix}|${state} pass:${passedCount} drop:${droppedCount}`,
+      });
+    }
+
+    function emitToOutputs(msg, droppedMeta) {
+      const outputs = [msg, null];
+      if (droppedMeta) {
+        outputs[0] = null;
+        outputs[1] = droppedMeta;
+      }
+      node.send(outputs);
+      sendStatus();
+    }
+
+    function clone(msg) {
+      return REDUtil.cloneMessage ? REDUtil.cloneMessage(msg) : JSON.parse(JSON.stringify(msg));
+    }
+
+    function emitForward(msg, nextState = 'idle') {
+      passedCount += 1;
+      currentState = nextState;
+      emitToOutputs(msg, null);
+    }
+
+    function emitDrop(reason, originalMsg, resolved) {
+      droppedCount += 1;
+      const dropState = {
+        'dropped-window': 'blocked',
+        'suppressed-debounce': 'cooldown',
+        'dropped-throttle': 'cooldown',
+      }[reason] || 'blocked';
+      currentState = dropState;
+      emitToOutputs(null, {
+        topic: `${controlTopic}/drop`,
+        payload: {
+          mode: currentMode,
+          reason,
+          msg: originalMsg,
+          passed: passedCount,
+          dropped: droppedCount,
+          property: payloadPropName,
+          propertyValue: resolved ? resolved.value : undefined,
+          propertyBoolean: resolved ? resolved.boolean : undefined,
+        },
+      });
+    }
+
+    let debounceTimer = null;
+    let debounceLeadingSent = false;
+    let pendingDebounceMessage = null;
+
+    let throttleTimer = null;
+    let throttleLastEmit = 0;
+    let throttlePendingMessage = null;
+
+    let windowTimestamps = [];
+    let windowQueueMessage = null;
+    let windowQueueTimer = null;
+
+    function clearDebounce() {
+      if (debounceTimer) {
+        timerBag.clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      debounceLeadingSent = false;
+      pendingDebounceMessage = null;
+    }
+
+    function clearThrottle() {
+      if (throttleTimer) {
+        timerBag.clearTimeout(throttleTimer);
+        throttleTimer = null;
+      }
+      throttlePendingMessage = null;
+    }
+
+    function clearWindowQueue() {
+      if (windowQueueTimer) {
+        timerBag.clearTimeout(windowQueueTimer);
+        windowQueueTimer = null;
+      }
+      windowQueueMessage = null;
+    }
+
+    function resetAll() {
+      clearDebounce();
+      clearThrottle();
+      clearWindowQueue();
+      windowTimestamps = [];
+      throttleLastEmit = 0;
+      currentState = 'idle';
+      sendStatus();
+    }
+
+    function flushPending() {
+      switch (currentMode) {
+        case 'debounce':
+          if (pendingDebounceMessage) {
+            const toSend = pendingDebounceMessage;
+            clearDebounce();
+            emitForward(toSend);
+          }
+          break;
+        case 'throttle':
+          if (throttlePendingMessage) {
+            const toSend = throttlePendingMessage;
+            throttlePendingMessage = null;
+            throttleLastEmit = Date.now();
+            emitForward(toSend);
+            if (throttleTimer) {
+              timerBag.clearTimeout(throttleTimer);
+              throttleTimer = null;
+            }
+          }
+          break;
+        case 'window':
+          if (windowQueueMessage) {
+            const queued = windowQueueMessage;
+            clearWindowQueue();
+            tryEmitWindow(queued.msg, queued.propertyValue);
+          }
+          break;
+        default:
+          break;
+      }
+    }
+
+    function handleControlMessage(msg) {
+      let consumed = false;
+      if (msg.reset === true) {
+        resetAll();
+        consumed = true;
+      }
+      if (msg.flush === true) {
+        flushPending();
+        consumed = true;
+      }
+      if (typeof msg.mode === 'string') {
+        const newMode = msg.mode.toLowerCase();
+        if (['debounce', 'throttle', 'window'].includes(newMode)) {
+          currentMode = newMode;
+          resetAll();
+          consumed = true;
+        }
+      }
+      if (typeof msg.interval === 'number') {
+        config.interval = msg.interval;
+        consumed = true;
+      }
+      if (typeof msg.wait === 'number') {
+        config.wait = msg.wait;
+        consumed = true;
+      }
+      if (typeof msg.windowSize === 'number') {
+        config.windowSize = msg.windowSize;
+        consumed = true;
+      }
+      if (typeof msg.maxInWindow === 'number') {
+        config.maxInWindow = msg.maxInWindow;
+        consumed = true;
+      }
+      return consumed;
+    }
+
+    function scheduleStats() {
+      if (Number(statInterval) > 0) {
+        timerBag.setInterval(() => {
+          node.send([
+            null,
+            {
+              topic: `${controlTopic}/stats`,
+              payload: {
+                mode: currentMode,
+                state: currentState,
+                passed: passedCount,
+                dropped: droppedCount,
+              },
+            },
+          ]);
+        }, Number(statInterval) * 1000);
+      }
+    }
+
+    function tryEmitWindow(msg, resolved) {
+      const now = Date.now();
+      const size = Number(config.windowSize || windowSize);
+      const max = Number(config.maxInWindow || maxInWindow);
+
+      windowTimestamps = windowTimestamps.filter((ts) => now - ts <= size);
+      if (windowTimestamps.length < max) {
+        const hadQueue = Boolean(windowQueueMessage);
+        emitForward(msg, hadQueue ? 'waiting' : 'idle');
+        windowTimestamps.push(now);
+        if (windowQueueMessage && !windowQueueTimer) {
+          const queued = windowQueueMessage;
+          windowQueueMessage = null;
+          const delay = size - (now - windowTimestamps[0]);
+          windowQueueTimer = timerBag.setTimeout(() => {
+            windowQueueTimer = null;
+            tryEmitWindow(queued.msg, queued.resolved);
+          }, Math.max(delay, 0));
+        }
+        return true;
+      }
+
+      if ((config.dropStrategy || dropStrategy) === 'queue') {
+        windowQueueMessage = { msg, resolved };
+        currentState = 'blocked';
+        if (!windowQueueTimer) {
+          const delay = size - (now - windowTimestamps[0]);
+          windowQueueTimer = timerBag.setTimeout(() => {
+            windowQueueTimer = null;
+            if (windowQueueMessage) {
+              const queued = windowQueueMessage;
+              windowQueueMessage = null;
+              tryEmitWindow(queued.msg, queued.resolved);
+            }
+          }, Math.max(delay, 0));
+        }
+      } else {
+        emitDrop('dropped-window', msg, resolved);
+      }
+      return false;
+    }
+
+    function handleDebounce(msg, resolved) {
+      const waitTime = Number(config.wait || wait);
+      const emitSetting = config.emitOn || emitOn;
+      const cloned = clone(msg);
+
+      if (debounceTimer) {
+        timerBag.clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+
+      pendingDebounceMessage = cloned;
+      currentState = 'waiting';
+
+      const shouldEmitLeading = (emitSetting === 'leading' || emitSetting === 'both') && !debounceLeadingSent;
+      if (shouldEmitLeading) {
+        emitForward(cloned, 'waiting');
+        debounceLeadingSent = true;
+      }
+
+      if (emitSetting === 'leading' && !shouldEmitLeading) {
+        emitDrop('suppressed-debounce', cloned, resolved);
+        return;
+      }
+
+      debounceTimer = timerBag.setTimeout(() => {
+        debounceTimer = null;
+        debounceLeadingSent = false;
+        const shouldEmitTrailing = emitSetting === 'trailing' || emitSetting === 'both';
+        if (shouldEmitTrailing && pendingDebounceMessage) {
+          const toSend = pendingDebounceMessage;
+          pendingDebounceMessage = null;
+          emitForward(toSend, 'idle');
+        } else {
+          pendingDebounceMessage = null;
+          currentState = 'idle';
+          sendStatus();
+        }
+      }, waitTime);
+    }
+
+    function handleThrottle(msg, resolved) {
+      const intervalMs = Number(config.interval || interval);
+      const trailingEnabled = Boolean(config.trailing ?? trailing);
+      const now = Date.now();
+      const cloned = clone(msg);
+
+      if (now - throttleLastEmit >= intervalMs) {
+        throttleLastEmit = now;
+        emitForward(cloned);
+        clearThrottle();
+        return;
+      }
+
+      if (!trailingEnabled) {
+        emitDrop('dropped-throttle', cloned, resolved);
+        return;
+      }
+
+      throttlePendingMessage = cloned;
+      currentState = 'cooldown';
+      if (!throttleTimer) {
+        const delay = intervalMs - (now - throttleLastEmit);
+        throttleTimer = timerBag.setTimeout(() => {
+          throttleTimer = null;
+          if (throttlePendingMessage) {
+            throttleLastEmit = Date.now();
+            const toSend = throttlePendingMessage;
+            throttlePendingMessage = null;
+            emitForward(toSend);
+          } else {
+            currentState = 'idle';
+            sendStatus();
+          }
+        }, delay);
+      }
+    }
+
+    function handleWindow(msg, resolved) {
+      const cloned = clone(msg);
+      if (!tryEmitWindow(cloned, resolved)) {
+        if ((config.dropStrategy || dropStrategy) !== 'queue') {
+          // Drop already emitted; ensure status reflects blocked state
+          currentState = 'blocked';
+          sendStatus();
+        }
+      }
+    }
+
+    node.on('input', function (msg) {
+      if (msg.topic === controlTopic) {
+        if (handleControlMessage(msg)) {
+          return;
+        }
+      }
+
+      const resolved = helpers.resolveInput(msg, payloadPropName, config.translatorConfig, RED);
+
+      switch (currentMode) {
+        case 'debounce':
+          handleDebounce(msg, resolved);
+          break;
+        case 'throttle':
+          handleThrottle(msg, resolved);
+          break;
+        case 'window':
+          handleWindow(msg, resolved);
+          break;
+        default:
+          emitForward(clone(msg));
+          break;
+      }
+    });
+
+    scheduleStats();
+    sendStatus();
+  }
+
+  RED.nodes.registerType('RateLimiterUltimate', RateLimiterUltimate);
+};

package/boolean-logic-ultimate/StaircaseLightUltimate.html

@@ -0,0 +1,165 @@
+<script type="text/javascript">
+  RED.nodes.registerType('StaircaseLightUltimate', {
+    category: 'Boolean Logic Ultimate',
+    color: '#ff8080',
+    defaults: {
+      name: { value: '' },
+      controlTopic: { value: 'stairs' },
+      payloadPropName: { value: 'payload', required: false },
+      translatorConfig: { type: 'translator-config', required: false },
+      durationSeconds: { value: 30, validate: RED.validators.number() },
+      warningEnabled: { value: true },
+      warningOffsetSeconds: { value: 5, validate: RED.validators.number() },
+      restartOnTrigger: { value: true },
+      allowOffInput: { value: false },
+      onPayload: { value: true },
+      onPayloadType: { value: 'bool' },
+      offPayload: { value: false },
+      offPayloadType: { value: 'bool' },
+      warningPayload: { value: 'warning' },
+      warningPayloadType: { value: 'str' }
+    },
+    inputs: 1,
+    outputs: 2,
+    outputLabels: ['Light command', 'Warning'],
+    icon: 'timer.png',
+    label: function () {
+      return this.name || 'Staircase Light';
+    },
+    paletteLabel: function () {
+      return 'Staircase Light';
+    },
+    oneditprepare: function () {
+      const payloadField = $('#node-input-payloadPropName');
+      if (payloadField.val() === '') payloadField.val('payload');
+      payloadField.typedInput({ default: 'msg', types: ['msg'] });
+
+      $('#node-input-onPayload').typedInput({
+        default: this.onPayloadType || 'bool',
+        types: ['str', 'num', 'bool', 'json', 'date']
+      });
+      $('#node-input-onPayload').typedInput('type', this.onPayloadType || 'bool');
+
+      $('#node-input-offPayload').typedInput({
+        default: this.offPayloadType || 'bool',
+        types: ['str', 'num', 'bool', 'json', 'date']
+      });
+      $('#node-input-offPayload').typedInput('type', this.offPayloadType || 'bool');
+
+      $('#node-input-warningPayload').typedInput({
+        default: this.warningPayloadType || 'str',
+        types: ['str', 'num', 'bool', 'json']
+      });
+      $('#node-input-warningPayload').typedInput('type', this.warningPayloadType || 'str');
+    },
+    oneditsave: function () {
+      this.onPayloadType = $('#node-input-onPayload').typedInput('type');
+      this.offPayloadType = $('#node-input-offPayload').typedInput('type');
+      this.warningPayloadType = $('#node-input-warningPayload').typedInput('type');
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="StaircaseLightUltimate">
+  <div class="form-row">
+    <b>Staircase Light Ultimate</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-durationSeconds"><i class="fa fa-clock-o"></i> Duration (s)</label>
+    <input type="number" id="node-input-durationSeconds" min="1">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-warningEnabled"><i class="fa fa-bell"></i> Warning before off</label>
+    <input type="checkbox" id="node-input-warningEnabled" style="width:auto; margin-top:7px;">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-warningOffsetSeconds"><i class="fa fa-hourglass-end"></i> Warning offset (s)</label>
+    <input type="number" id="node-input-warningOffsetSeconds" min="1">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-restartOnTrigger"><i class="fa fa-repeat"></i> Restart on trigger</label>
+    <input type="checkbox" id="node-input-restartOnTrigger" style="width:auto; margin-top:7px;">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-allowOffInput"><i class="fa fa-power-off"></i> Allow off input</label>
+    <input type="checkbox" id="node-input-allowOffInput" style="width:auto; margin-top:7px;">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-payloadPropName"><i class="fa fa-ellipsis-h"></i> With 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>
+
+  <div class="form-row">
+    <label for="node-input-onPayload"><i class="fa fa-lightbulb-o"></i> On payload</label>
+    <input type="text" id="node-input-onPayload">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-offPayload"><i class="fa fa-lightbulb-o"></i> Off payload</label>
+    <input type="text" id="node-input-offPayload">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-warningPayload"><i class="fa fa-exclamation-triangle"></i> Warning payload</label>
+    <input type="text" id="node-input-warningPayload">
+  </div>
+</script>
+
+<script type="text/markdown" data-help-name="StaircaseLightUltimate">
+<p>The purpose of this node is to control staircase lighting with timed auto-off and optional warning messages.</p>
+
+|Property|Description|
+|--|--|
+| Control topic | Topic that receives manual commands (on/off/extend). |
+| Duration (s) | Length of the lighting period for each trigger. |
+| Warning before off | Enables emission of a pre-off warning on output 2. |
+| Warning offset (s) | Seconds before switch-off when the warning is sent. |
+| Restart on trigger | Restarts the timer every time a new trigger arrives while active. |
+| Allow off input | Allows a `false` from the main input to switch off immediately. |
+| With Input | Message property to evaluate as trigger (default `payload`). |
+| Translator | Optional translator-config for true/false conversion. |
+| On/Off payload | Values emitted on output 1 to switch the light. |
+| Warning payload | Value emitted on output 2 when the warning fires. |
+
+<br/>
+
+* Control topic commands (`msg.topic` must match the control topic)
+
+Pass <code>msg.command = "on"</code> (or <code>msg.start = true</code>) to turn on and start the timer</br>
+Pass <code>msg.command = "off"</code> (or <code>msg.stop = true</code>) to force immediate off</br>
+Pass <code>msg.command = "extend"</code> (or <code>msg.extend = true</code>) to refresh the timer while keeping the light on</br>
+Pass <code>msg.duration</code>, <code>msg.warningEnabled</code> or <code>msg.warningOffset</code> to update runtime settings</br>
+
+<br/>
+
+Output 1 emits the configured ON/OFF command. Output 2 emits the pre-off warning and includes <code>msg.remaining</code> with the seconds left.</br>
+
+<br/>
+
+[SEE THE README FOR FULL HELP AND SAMPLES](https://github.com/Supergiovane/node-red-contrib-boolean-logic-ultimate)</br>
+
+[Find it useful?](https://www.paypal.me/techtoday)
+
+</script>