@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/and-block.js

@@ -0,0 +1,73 @@
+module.exports = function(RED) {
+    function AndBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Initialize state
+        node.inputs = Array(parseInt(config.slots) || 2).fill(false);
+        node.slots = parseInt(config.slots);
+
+        node.status({ fill: "green", shape: "dot", text: `slots: ${node.slots}` });
+
+        // Initialize fields
+        let lastResult = null;
+        let lastInputs = node.inputs.slice();
+
+        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;
+            }
+
+            // Check required properties
+            if (!msg.hasOwnProperty("context")) {
+                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                if (done) done();
+                return;
+            }
+
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Process input slot
+            if (msg.context.startsWith("in")) {
+                let index = parseInt(msg.context.slice(2), 10);
+                if (!isNaN(index) && index >= 1 && index <= node.slots) {
+                    node.inputs[index - 1] = Boolean(msg.payload);
+                    const result = node.inputs.every(v => v === true);
+                    const isUnchanged = result === lastResult && node.inputs.every((v, i) => v === lastInputs[i]);
+                    node.status({
+                        fill: "blue",
+                        shape: isUnchanged ? "ring" : "dot",
+                        text: `in: [${node.inputs.join(", ")}], out: ${result}`
+                    });
+                    lastResult = result;
+                    lastInputs = node.inputs.slice();
+                    send({ payload: result });
+                    if (done) done();
+                    return;
+                } else {
+                    node.status({ fill: "red", shape: "ring", text: `invalid input index ${index || "NaN"}` });
+                    if (done) done();
+                    return;
+                }
+            }
+
+            node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("and-block", AndBlockNode);
+};

package/nodes/average-block.html

@@ -0,0 +1,97 @@
+<script type="text/html" data-template-name="average-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-sampleSize" title="Rolling window size (positive integer, e.g., 10)"><i class="fa fa-list-ol"></i> Window Size</label>
+        <input type="number" id="node-input-sampleSize" placeholder="10" min="1" step="1">
+    </div>
+    <div class="form-row">
+        <label for="node-input-minValid"><i class="fa fa-arrow-down"></i> Minimum Valid</label>
+        <input type="text" id="node-input-minValid" placeholder="150">
+        <input type="hidden" id="node-input-minValidType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxValid"><i class="fa fa-arrow-up"></i> Maximum Valid</label>
+        <input type="text" id="node-input-maxValid" placeholder="1">
+        <input type="hidden" id="node-input-maxValidType">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("average-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            sampleSize: {
+                value: 10,
+                required: true,
+                validate: function(v) { return !isNaN(parseInt(v)) && parseInt(v) >= 1; }
+            },
+            minValid: { value: 1, required: true },
+            minValidType: { value: "num" },
+            maxValid: { value: 150, required: true },
+            maxValidType: { value: "num" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["average"],
+        icon: "join.svg",
+        paletteLabel: "average",
+        label: function() {
+            return this.name ? `${this.name} (${this.sampleSize})` : `average (${this.sampleSize})`;
+        },
+        oneditprepare: function() {
+            const node = this;
+
+            try {
+                // Initialize typed inputs
+                $("#node-input-minValid").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-minValidType"
+                }).typedInput("type", node.minValidType || "num").typedInput("value", node.minValid || "1");
+
+                $("#node-input-maxValid").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-maxValidType"
+                }).typedInput("type", node.maxValidType || "num").typedInput("value", node.maxValid || "150");
+            } catch (err) {
+                console.error("Error in hysteresis-block oneditprepare:", err);
+            }
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="average-block">
+Computes a rolling average of numeric inputs within a valid range.
+
+### Inputs
+: context (string) : Configures reset (`"reset"`) or window size (`"sampleSize"`).
+: payload (number | boolean) : Number for averaging, boolean for reset.
+: minValid (number) : Minimum valid range for payload input.
+: maxValid (number) : Maximum valid range for payload input.
+
+### Outputs
+: payload (number | null) : Rolling average, or `null` if no valid inputs.
+
+### Details
+Averages numeric `msg.payload` values over a rolling window (default: 10).
+
+Resets state (`sum`, `count`) via `msg.context = "reset"` with `msg.payload = true`.
+
+### 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/average-block.js

@@ -0,0 +1,137 @@
+module.exports = function(RED) {
+    function AverageBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            maxValues: parseInt(config.sampleSize),
+            values: [], // Queue for rolling window
+            lastAvg: null
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.maxValues) || node.runtime.maxValues < 1) {
+            node.runtime.maxValues = 10;
+            node.status({ fill: "red", shape: "ring", text: "invalid window size, using 10" });
+        } else {
+            node.status({ shape: "dot", text: `name: ${config.name}, window: ${config.sampleSize}` });
+        }
+
+        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;
+            }
+
+            // Evaluate all properties
+            try {
+                node.runtime.minValid = RED.util.evaluateNodeProperty(
+                    config.minValid, config.minValidType, node, msg
+                );
+
+                node.runtime.maxValid = RED.util.evaluateNodeProperty(
+                    config.maxValid, config.maxValidType, node, msg
+                );
+                
+                // Validate values
+                if (isNaN(node.runtime.maxValid) || isNaN(node.runtime.minValid) || node.runtime.maxValid <= node.runtime.minValid ) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid evaluated values ${node.runtime.minValid}, ${node.runtime.maxValid}` });
+                    if (done) done();
+                    return;
+                }
+            } catch(err) {
+                node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
+                if (done) done(err);
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+                
+                switch (msg.context) {
+                    case "reset":
+                        if (typeof msg.payload !== "boolean") {
+                            node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                            if (done) done();
+                            return;
+                        }
+                        if (msg.payload === true) {
+                            node.runtime.values = [];
+                            node.runtime.lastAvg = null;
+                            node.status({ fill: "green", shape: "dot", text: "state reset" });
+                        }
+                        break;
+                        
+                    case "sampleSize":
+                        let newMaxValues = parseInt(msg.payload);
+                        if (isNaN(newMaxValues) || newMaxValues < 1) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid window size" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.maxValues = newMaxValues;
+                        // Trim values if new window is smaller
+                        if (node.runtime.values.length > newMaxValues) {
+                            node.runtime.values = node.runtime.values.slice(-newMaxValues);
+                        }
+                        node.status({ fill: "green", shape: "dot", text: `window: ${newMaxValues}` });
+                        break;
+                        
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        break;
+                }                
+                if (done) done();
+                return;
+            }
+
+            // Check for missing payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Process input
+            const inputValue = parseFloat(msg.payload);
+            if (isNaN(inputValue) || inputValue < node.runtime.minValid || inputValue > node.runtime.maxValid) {
+                node.status({ fill: "yellow", shape: "ring", text: "out of range" });
+                if (done) done();
+                return;
+            }
+
+            // Update rolling window
+            node.runtime.values.push(inputValue);
+            if (node.runtime.values.length > node.runtime.maxValues) {
+                node.runtime.values.shift();
+            }
+
+            // Calculate average
+            const avg = node.runtime.values.length ? node.runtime.values.reduce((a, b) => a + b, 0) / node.runtime.values.length : null;
+            const isUnchanged = avg === node.runtime.lastAvg;
+
+            // Send new message
+            node.status({ fill: "blue", shape: isUnchanged ? "ring" : "dot", text: `out: ${avg !== null ? avg.toFixed(3) : "null"}` });
+            node.runtime.lastAvg = avg;
+            send({ payload: avg });
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("average-block", AverageBlockNode);
+};

package/nodes/boolean-switch-block.html

@@ -0,0 +1,59 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="boolean-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>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("boolean-switch-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" }
+        },
+        inputs: 1,
+        outputs: 3,
+        inputLabels: ["control"],
+        outputLabels: ["outTrue", "outFalse", "outControl"],
+        icon: "font-awesome/fa-toggle-on",
+        paletteLabel: "boolean switch",
+        label: function() {
+            return this.name || "boolean switch";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="boolean-switch-block">
+Routes input flows to one of three outputs based on a boolean switch state.
+
+### Inputs
+: context (string) : Configuration commands (`toggle`, `switch`, `inTrue`, `inFalse`).
+: payload (any) : Flow data for `"inTrue"` or `"inFalse"`.
+
+### Outputs
+: outTrue (msg) : Receives `msg` with `context "inTrue"` when switch is `true`.
+: outFalse (msg) : Receives `msg` with `context "inFalse"` when switch is `false`.
+: outControl (msg) : `msg.payload` set to switch state on toggle.
+
+### Details
+Routes input messages to one of three outputs based on a boolean switch state (`true` or `false`).
+
+Messages with `msg.context = "inTrue"` are sent to `outTrue` when `state = true`, and messages with `msg.context = "inFalse"` are sent to `outFalse` when `state = false`.
+
+State can be controlled directly with the `"switch"` property given a `msg.payload` boolean value.
+
+### 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/boolean-switch-block.js

@@ -0,0 +1,88 @@
+module.exports = function(RED) {
+    function BooleanSwitchBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize state from config
+        node.state = config.state !== undefined ? Boolean(config.state) : false;
+
+        // Set initial status
+        node.status({
+            fill: "green",
+            shape: "dot",
+            text: `state: ${node.state}`
+        });
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Validate context
+            if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
+                node.status({ fill: "red", shape: "ring", text: "missing or invalid context" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context commands
+            switch (msg.context) {
+                case "toggle":
+                    node.state = !node.state;
+                    node.status({
+                        fill: "green",
+                        shape: "dot",
+                        text: `state: ${node.state}`
+                    });
+                    send([null, null, { payload: node.state }]);
+                    break;
+                case "switch":
+                    node.state = !!msg.payload;
+                    node.status({
+                        fill: "green",
+                        shape: "dot",
+                        text: `state: ${node.state}`
+                    });
+                    send([null, null, { payload: node.state }]);
+                    break;
+                case "inTrue":
+                    if (node.state) {
+                        node.status({
+                            fill: "blue",
+                            shape: "dot",
+                            text: `out: ${msg.payload}`
+                        });
+                        send([msg, null, { payload: node.state }]);
+                    }
+                    break;
+                case "inFalse":
+                    if (!node.state) {
+                        node.status({
+                            fill: "blue",
+                            shape: "dot",
+                            text: `out: ${msg.payload}`
+                        });
+                        send([null, msg, { payload: node.state }]);
+                    }
+                    break;
+                default:
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done("Unknown context");
+                    return;
+            }
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            node.status({});
+            done();
+        });
+    }
+
+    RED.nodes.registerType("boolean-switch-block", BooleanSwitchBlockNode);
+};

package/nodes/boolean-to-number-block.html

@@ -0,0 +1,59 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="boolean-to-number-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-nullToZero"><i class="fa fa-cog"></i> Null Mapping</label>
+        <input type="checkbox" id="node-input-nullToZero" style="width: auto; margin-left: 10px;"> Map null to 0
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("boolean-to-number-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            nullToZero: { value: false }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-calculator",
+        paletteLabel: "boolean to number",
+        label: function() {
+            return this.name || "boolean to number";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="boolean-to-number-block">
+Converts a boolean or null input payload to a numeric output.
+
+### Inputs
+: payload (boolean | null) : Value to convert (`true`, `false`, `null`).
+
+### Outputs
+: payload (number) : Converted value `null` to `0` (if `nullToZero`) or `-1`, `false` to `0`, `true` to `1`.
+
+### Details
+Converts `msg.payload` (boolean or null) to a number `null` maps to `0` (if `nullToZero` is `true`) or `-1` (if `false`), `false` to `0`, `true` to `1`. 
+
+Passthrough all other input message properties
+
+### 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/boolean-to-number-block.js

@@ -0,0 +1,45 @@
+module.exports = function(RED) {
+    function BooleanToNumberBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime for editor display
+        node.runtime = {
+            name: config.name,
+            nullToZero: Boolean(config.nullToZero)
+        };
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Check for missing payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Validate and convert payload
+            const inputDisplay = msg.payload === null ? "null" : String(msg.payload);
+            if (msg.payload === null) {
+                msg.payload = node.runtime.nullToZero ? 0 : -1;
+                node.status({ fill: "blue", shape: "dot", text: `in: ${inputDisplay}, out: ${msg.payload}` });
+                send(msg);
+            } else if (typeof msg.payload === "boolean") {
+                msg.payload = msg.payload ? 1 : 0;
+                node.status({ fill: "blue", shape: "dot", text: `in: ${inputDisplay}, out: ${msg.payload}` });
+                send(msg);
+            } else {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("boolean-to-number-block", BooleanToNumberBlockNode);
+};

package/nodes/cache-block.html

@@ -0,0 +1,69 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="cache-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-operationMode" title="Choose whether to output the full cloned message or only the payload"><i class="fa fa-cog"></i> Operation Mode</label>
+        <input type="text" id="node-input-operationMode" placeholder="payload">
+    </div>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("cache-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            operationMode: { value: "payload", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-database",
+        paletteLabel: "cache",
+        label: function() {
+            return this.name || "cache";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="cache-block">
+Caches an input message and outputs either a copy or just the payload based on configuration.
+
+### Inputs
+: context (string) : Sets action (`"update"` to store, `"execute"` to output, `"reset"` to clear).  
+Unmatched values trigger an error.
+: payload (any | boolean) : Value to store (`update`), ignored for `execute`, boolean `true` for `reset`.
+
+### Outputs
+: payload (any) : Cached value when `execute` is triggered; `null` if cache is empty.  
+: other properties : Included only if "Clone Message" mode is selected.
+
+### Properties
+: name (string) : Display name in editor. Default; "".  
+: operationMode (string) : Selects output behavior; "Clone Message" (full message) or "Payload Only" (just payload).
+
+### Details
+Stores the entire input message when `msg.context = "update"`.  
+
+Outputs either a full copy of the cached message (`operationMode = "Clone Message"`) 
+or a new message with only the cached `msg.payload`
+
+Clears the cache to `null` when `msg.context = "reset"` with `msg.payload = true`.  
+
+### 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>