@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/minmax-block.js

@@ -0,0 +1,119 @@
+module.exports = function(RED) {
+    function MinMaxBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+        };
+
+        // Store last output value for status
+        let lastOutput = null;
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Evaluate typed-inputs
+            try {
+                node.runtime.min = RED.util.evaluateNodeProperty(
+                    config.min, config.minType, node, msg
+                );
+
+                node.runtime.max = RED.util.evaluateNodeProperty(
+                    config.max, config.maxType, node, msg
+                );
+                
+
+                // Validate min and max at startup
+                if (isNaN(node.runtime.min) || isNaN(node.runtime.max) || node.runtime.min > node.runtime.max) {
+                    node.status({ fill: "red", shape: "dot", text: `invalid min/max` });
+                    if (done) done();
+                    return;
+                }
+            } catch(err) {
+                node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
+                if (done) done(err);
+                return;
+            }
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                const value = parseFloat(msg.payload);
+                if (isNaN(value) || value < 0) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                if (msg.context === "min") {
+                    if (value < node.runtime.max) {
+                        node.runtime.min = value;
+                        node.status({ fill: "green", shape: "dot", text: `min: ${node.runtime.min}` });
+                    } else {
+                        node.status({ fill: "yellow", shape: "dot", text: `Context update aborted. Payload more than max` });
+                    }
+                } else if (msg.context === "max") {
+                    if (value > node.runtime.max) {
+                        node.runtime.max = value;
+                        node.status({ fill: "green", shape: "dot", text: `max: ${node.runtime.max}` });
+                    } else {
+                        node.status({ fill: "yellow", shape: "dot", text: `Context update aborted. Payload less than min` });
+                    }
+                } else {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done();
+                    return;
+                }
+                if (done) done();
+                return;
+            }
+
+            // Validate input payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = parseFloat(msg.payload);
+            if (isNaN(inputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                if (done) done();
+                return;
+            }
+
+            // Clamp input to [min, max]
+            const outputValue = Math.min(Math.max(inputValue, node.runtime.min), node.runtime.max);
+
+            // Update status and send output
+            msg.payload = outputValue;
+            node.status({
+                fill: "blue",
+                shape: lastOutput === outputValue ? "ring" : "dot",
+                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
+            });
+            lastOutput = outputValue;
+            send(msg);
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("minmax-block", MinMaxBlockNode);
+};

package/nodes/modulo-block.html

@@ -0,0 +1,73 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="modulo-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-slots" title="Number of input slots (positive integer, e.g., 2)"><i class="fa fa-list-ol"></i> Slots</label>
+        <input type="number" id="node-input-slots" placeholder="2" min="1" step="1">
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("modulo-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            slots: {
+                value: 2,
+                required: true,
+                validate: function(v) { return !isNaN(parseInt(v)) && parseInt(v) >= 1; }
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["remainder"],
+        icon: "font-awesome/fa-percent",
+        paletteLabel: "modulo",
+        label: function() {
+            return this.name ? `${this.name} (${this.slots})` : `modulo (${this.slots})`;
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="modulo-block">
+Computes the modulo (remainder) of numeric inputs from multiple slots in sequence.
+
+### Inputs
+: context (string) : Configures reset (`"reset"`), slots (`"slots"`), or identifies input slot (e.g., `"in1"`, `"in2"`).
+: payload (number | boolean | integer) : Number for slot input, boolean for reset, integer for slots configuration.
+
+### Outputs
+: payload (number) : Result of modulo operation (in1 % in2 % ...).
+
+### Properties
+: slots (number) : Number of input slots (positive integer).
+
+### Details
+Computes the modulo of numeric `msg.payload` values from slots identified by `msg.context` (e.g., `"in1"`, `"in2"`) in sequence (in1 % in2 % ...). 
+
+Slots are set via editor or `msg.context = "slots"` with positive integer. 
+
+Inputs default to 1, updated via `msg.context = "inX"`. 
+Inputs for `in2` onward must be non-zero to avoid modulo by zero. 
+Resets inputs to 1 via `msg.context = "reset"` with `msg.payload = true`. 
+
+Outputs only when the result changes.
+
+### 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/modulo-block.js

@@ -0,0 +1,126 @@
+module.exports = function(RED) {
+    function ModuloBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            slots: parseInt(config.slots),
+            inputs: Array(parseInt(config.slots) || 2).fill(1),
+            lastResult: null
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.slots) || node.runtime.slots < 1) {
+            node.runtime.slots = 2;
+            node.runtime.inputs = Array(2).fill(1);
+            node.status({ fill: "red", shape: "ring", text: "invalid slots, using 2" });
+        } else {
+            node.status({ fill: "green", shape: "dot", text: `name: ${node.runtime.name || "modulo"}, slots: ${node.runtime.slots}` });
+        }
+
+        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;
+            }
+
+            // Check for missing context or payload
+            if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
+                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;
+            }
+
+            // Handle configuration messages
+            if (msg.context === "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.inputs = Array(node.runtime.slots).fill(1);
+                    node.runtime.lastResult = null;
+                    node.status({ fill: "green", shape: "dot", text: "state reset" });
+                    if (done) done();
+                    return;
+                }
+                if (done) done();
+                return;
+            }
+
+            if (msg.context === "slots") {
+                const newSlots = parseInt(msg.payload);
+                if (isNaN(newSlots) || newSlots < 1) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid slots" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.slots = newSlots;
+                node.runtime.inputs = Array(newSlots).fill(1);
+                node.runtime.lastResult = null;
+                node.status({ fill: "green", shape: "dot", text: `slots: ${newSlots}` });
+                if (done) done();
+                return;
+            }
+
+            if (msg.context.startsWith("in")) {
+                const slotIndex = parseInt(msg.context.slice(2)) - 1;
+                if (isNaN(slotIndex) || slotIndex < 0 || slotIndex >= node.runtime.slots) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid input slot ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                const newValue = parseFloat(msg.payload);
+                if (isNaN(newValue) || !isFinite(newValue)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                    if (done) done();
+                    return;
+                }
+                if (slotIndex > 0 && newValue === 0) {
+                    node.status({ fill: "red", shape: "ring", text: "modulo by zero" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.inputs[slotIndex] = newValue;
+
+                // Calculate modulo
+                const result = node.runtime.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc % val, node.runtime.inputs[0]);
+                const isUnchanged = result === node.runtime.lastResult;
+                node.status({
+                    fill: "blue",
+                    shape: isUnchanged ? "ring" : "dot",
+                    text: `in: ${msg.context}=${newValue.toFixed(2)}, out: ${result.toFixed(2)}`
+                });
+
+                if (!isUnchanged) {
+                    node.runtime.lastResult = result;
+                    send({ payload: result });
+                }
+                if (done) done();
+                return;
+            }
+
+            node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+            if (done) done("Unknown context");
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("modulo-block", ModuloBlockNode);
+};

package/nodes/multiply-block.html

@@ -0,0 +1,63 @@
+<script type="text/html" data-template-name="multiply-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-slots" title="Number of input slots (positive integer, e.g., 2)"><i class="fa fa-list-ol"></i> Slots</label>
+        <input type="number" id="node-input-slots" placeholder="2" min="1" step="1">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("multiply-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            slots: {
+                value: 2,
+                required: true,
+                validate: function(v) { return !isNaN(parseInt(v)) && parseInt(v) >= 1; }
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["product"],
+        icon: "font-awesome/fa-times",
+        paletteLabel: "multiply",
+        label: function() {
+            return this.name ? `${this.name} (${this.slots})` : `multiply (${this.slots})`;
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="multiply-block">
+Multiplies numeric inputs from multiple slots.
+
+### Inputs
+: context (string) : Configures reset (`"reset"`), slots (`"slots"`), or identifies input slot (e.g., `"in1"`, `"in2"`).
+: payload (number | boolean) : Number for slot input, boolean for reset, integer for slots configuration.
+
+### Outputs
+: payload (number) : Product of all slot values.
+
+### Details
+Multiplies numeric `msg.payload` values from slots identified by `msg.context` (e.g., `"in1"`, `"in2"`). 
+
+Slots are set via editor or `msg.context = "slots"` with positive integer. Inputs default to 1, updated via `msg.context = "inX"`. 
+
+Resets inputs to 1 via `msg.context = "reset"` with `msg.payload = true`. Outputs only when the product changes.
+
+### 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/multiply-block.js

@@ -0,0 +1,115 @@
+module.exports = function(RED) {
+    function MultiplyBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            slots: parseInt(config.slots),
+            inputs: Array(parseInt(config.slots) || 2).fill(1),
+            lastResult: null
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.slots) || node.runtime.slots < 1) {
+            node.runtime.slots = 2;
+            node.runtime.inputs = Array(2).fill(1);
+            node.status({ fill: "red", shape: "ring", text: "invalid slots, using 2" });
+        } else {
+            node.status({ fill: "green", shape: "dot", text: `name: ${node.runtime.name}, slots: ${node.runtime.slots}` });
+        }
+
+        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 for missing context or payload
+            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;
+            }
+
+            // Handle configuration messages
+            if (msg.context === "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.inputs = Array(node.runtime.slots).fill(1);
+                    node.runtime.lastResult = null;
+                    node.status({ fill: "green", shape: "dot", text: "state reset" });
+                    if (done) done();
+                    return;
+                }
+            } else if (msg.context === "slots") {
+                let newSlots = parseInt(msg.payload);
+                if (isNaN(newSlots) || newSlots < 1) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid slots" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.slots = newSlots;
+                node.runtime.inputs = Array(newSlots).fill(1);
+                node.runtime.lastResult = null;
+                node.status({ fill: "green", shape: "dot", text: `slots: ${node.runtime.slots}` });
+                if (done) done();
+                return;
+            } else if (msg.context.startsWith("in")) {
+                let slotIndex = parseInt(msg.context.slice(2)) - 1;
+                if (isNaN(slotIndex) || slotIndex < 0 || slotIndex >= node.runtime.slots) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid input slot ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                let newValue = parseFloat(msg.payload);
+                if (isNaN(newValue)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.inputs[slotIndex] = newValue;
+                // Calculate product
+                const product = node.runtime.inputs.reduce((acc, val) => acc * val, 1);
+                const isUnchanged = product === node.runtime.lastResult;
+                node.status({
+                    fill: "blue",
+                    shape: isUnchanged ? "ring" : "dot",
+                    text: `in: ${msg.context}=${newValue.toFixed(2)}, out: ${product.toFixed(2)}`
+                });
+                if (!isUnchanged) {
+                    node.runtime.lastResult = product;
+                    send({ payload: product });
+                }
+                if (done) done();
+                return;
+            } else {
+                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                if (done) done();
+                return;
+            }
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("multiply-block", MultiplyBlockNode);
+};

package/nodes/negate-block.html

@@ -0,0 +1,55 @@
+<script type="text/html" data-template-name="negate-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>
+
+<script type="text/javascript">
+    RED.nodes.registerType("negate-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-minus",
+        paletteLabel: "negate",
+        label: function() {
+            return this.name || "negate";
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="negate-block">
+Negates a number or boolean input value.
+
+### Inputs
+: payload (number | boolean) : Value to negate (number or boolean).
+
+### Outputs
+: payload (number | boolean) : Negated value (-number or !boolean).
+
+### Details
+Negates `msg.payload` in a passthrough manner, updating the original message.
+- For numbers, outputs the negative (e.g., 5 becomes -5). 
+- For booleans, outputs the inverse (e.g., true becomes false). 
+
+Preserves other message properties (e.g., `msg.topic`, `msg.context`). 
+
+Outputs only when the negated value changes.
+
+### 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/negate-block.js

@@ -0,0 +1,91 @@
+module.exports = function(RED) {
+    function NegateBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            lastOutput: null
+        };
+
+        // Set initial status
+        node.status({
+            fill: "green",
+            shape: "dot",
+            text: `name: ${node.runtime.name}`
+        });
+
+        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: "missing message" });
+                if (done) done();
+                return;
+            }
+
+            // Check for missing payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing input" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = msg.payload;
+            let outputValue;
+            let statusText;
+
+            if (typeof inputValue === "number") {
+                if (isNaN(inputValue)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input: NaN" });
+                    if (done) done();
+                    return;
+                }
+                outputValue = -inputValue;
+                statusText = `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`;
+            } else if (typeof inputValue === "boolean") {
+                outputValue = !inputValue;
+                statusText = `in: ${inputValue}, out: ${outputValue}`;
+            } else {
+                let errorText;
+                if (inputValue === null) {
+                    errorText = "invalid input: null";
+                } else if (Array.isArray(inputValue)) {
+                    errorText = "invalid input: array";
+                } else if (typeof inputValue === "string") {
+                    errorText = "invalid input: string";
+                } else {
+                    errorText = "invalid input type";
+                }
+                node.status({ fill: "red", shape: "ring", text: errorText });
+                if (done) done();
+                return;
+            }
+
+            // Check for unchanged output
+            const isUnchanged = outputValue === node.runtime.lastOutput;
+            node.status({
+                fill: "blue",
+                shape: isUnchanged ? "ring" : "dot",
+                text: statusText
+            });
+
+            if (!isUnchanged) {
+                node.runtime.lastOutput = outputValue;
+                msg.payload = outputValue;
+                send(msg);
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("negate-block", NegateBlockNode);
+};