node-red-contrib-event-calc 0.1.1 → 0.1.4

package/nodes/event-calc.js

@@ -2,7 +2,7 @@
  * event-calc - Calculation node for multi-topic expressions
  *
  * Features:
- * - Maps multiple variables to topic patterns
+ * - Maps variables to exact topics
  * - Evaluates JavaScript expressions when inputs update
  * - Trigger modes: 'any' (any input updates) or 'all' (all inputs have values)
  * - Safe expression evaluation using Function constructor
@@ -10,6 +10,7 @@
  * - Built-in helper functions for common operations
  */
 module.exports = function(RED) {
+
     // Helper functions available in expressions
     const helpers = {
         // Math shortcuts
@@ -67,7 +68,6 @@ module.exports = function(RED) {
         node.outputTopic = config.outputTopic || 'calc/result';
 
         const subscriptionIds = [];
-        const latestValues = new Map(); // name -> { topic, value, ts }
 
         if (!node.cacheConfig) {
             node.status({ fill: "red", shape: "ring", text: "no cache configured" });
@@ -84,32 +84,43 @@ module.exports = function(RED) {
             return;
         }
 
+        // Track subscribed topics to ignore updates from our own output
+        const subscribedTopics = new Set();
+        for (const input of node.inputMappings) {
+            const topicName = input.topic || input.pattern;
+            if (topicName) {
+                subscribedTopics.add(topicName);
+            }
+        }
+
         /**
          * Attempt to calculate and output result
          */
-        function tryCalculate(triggerTopic) {
-            // Check if we should trigger
+        function tryCalculate(triggerTopic, latestValues) {
+            // Ignore updates triggered by our own output
+            if (triggerTopic === node.outputTopic) {
+                return;
+            }
+
             if (node.triggerOn === 'all') {
-                // All inputs must have values
                 for (const input of node.inputMappings) {
                     if (!latestValues.has(input.name)) {
-                        return; // Not all values available yet
+                        return;
                     }
                 }
             }
 
-            // At least one value must exist to calculate
             if (latestValues.size === 0) {
                 return;
             }
 
-            // Build context object for expression evaluation
             const context = {};
             const inputDetails = {};
+            const missingInputs = [];
 
             for (const input of node.inputMappings) {
                 const data = latestValues.get(input.name);
-                if (data) {
+                if (data && data.value !== undefined && data.value !== null) {
                     context[input.name] = data.value;
                     inputDetails[input.name] = {
                         topic: data.topic,
@@ -118,63 +129,98 @@ module.exports = function(RED) {
                     };
                 } else {
                     context[input.name] = undefined;
+                    missingInputs.push(input.name);
                 }
             }
 
-            // Evaluate expression safely
+            // Build topics mapping: variable name -> topic
+            const topics = { _output: node.outputTopic };
+            const timestamps = {};
+            for (const [name, details] of Object.entries(inputDetails)) {
+                topics[name] = details.topic;
+                timestamps[name] = details.ts;
+            }
+
             try {
-                // Create a function with named parameters from context + helpers
                 const allParams = { ...helpers, ...context };
                 const paramNames = Object.keys(allParams);
                 const paramValues = Object.values(allParams);
 
-                // Build function body with helpers and variables available
                 const fn = new Function(...paramNames, `return ${node.expression};`);
                 const result = fn(...paramValues);
 
+                // Check for NaN or invalid result
+                if (typeof result === 'number' && isNaN(result)) {
+                    const errorMsg = {
+                        topic: node.outputTopic,
+                        payload: {
+                            error: 'Expression resulted in NaN',
+                            missingInputs: missingInputs,
+                            expression: node.expression
+                        },
+                        inputs: inputDetails,
+                        trigger: triggerTopic,
+                        timestamp: Date.now()
+                    };
+                    node.send([null, errorMsg]);
+                    node.status({ fill: "yellow", shape: "ring", text: "NaN" });
+                    return;
+                }
+
                 const msg = {
                     topic: node.outputTopic,
                     payload: result,
+                    topics: topics,
                     inputs: inputDetails,
+                    timestamps: timestamps,
                     expression: node.expression,
                     trigger: triggerTopic,
                     timestamp: Date.now()
                 };
 
-                node.send(msg);
+                node.send([msg, null]);
 
-                // Store result back in cache so it can be used by other calculations
                 node.cacheConfig.setValue(node.outputTopic, result, {
                     source: 'event-calc',
                     expression: node.expression,
                     inputs: Object.keys(inputDetails)
                 });
 
-                // Update status with result (truncate if too long)
                 const resultStr = String(result);
                 const displayResult = resultStr.length > 15 ? resultStr.substring(0, 12) + '...' : resultStr;
                 node.status({ fill: "green", shape: "dot", text: `= ${displayResult}` });
 
             } catch (err) {
+                const errorMsg = {
+                    topic: node.outputTopic,
+                    payload: {
+                        error: err.message,
+                        expression: node.expression,
+                        context: context
+                    },
+                    inputs: inputDetails,
+                    trigger: triggerTopic,
+                    timestamp: Date.now()
+                };
+                node.send([null, errorMsg]);
                 node.status({ fill: "red", shape: "ring", text: "eval error" });
-                node.error(`Expression evaluation failed: ${err.message}`, { expression: node.expression, context: context });
             }
         }
 
-        // Subscribe to each input pattern
+        // Subscribe to inputs
+        const latestValues = new Map();
+
         for (const input of node.inputMappings) {
-            if (!input.name || !input.pattern) {
-                continue;
-            }
+            const topicName = input.topic || input.pattern;
+            if (!input.name || !topicName) continue;
 
-            const subId = node.cacheConfig.subscribe(input.pattern, (topic, entry) => {
+            const subId = node.cacheConfig.subscribe(topicName, (topic, entry) => {
                 latestValues.set(input.name, {
                     topic: topic,
                     value: entry.value,
                     ts: entry.ts
                 });
-
-                tryCalculate(topic);
+                tryCalculate(topic, latestValues);
             });
             subscriptionIds.push(subId);
         }
@@ -193,9 +239,11 @@ module.exports = function(RED) {
                 node.status({ fill: "blue", shape: "dot", text: "expr updated" });
             }
 
-            // Force recalculation
+            // Force recalculation (use special topic to bypass self-output check)
             if (msg.payload === 'recalc' || msg.topic === 'recalc') {
-                tryCalculate('manual');
+                if (latestValues.size > 0) {
+                    tryCalculate('_recalc', latestValues);
+                }
             }
 
             done();
@@ -208,7 +256,6 @@ module.exports = function(RED) {
                 }
             }
             subscriptionIds.length = 0;
-            latestValues.clear();
             done();
         });
     }

package/nodes/event-chart.html

@@ -0,0 +1,239 @@
+<style>
+    .event-calc-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="event-chart"] .red-ui-palette-label { color: #ffffff !important; }
+</style>
+
+<script type="text/javascript">
+    RED.nodes.registerType('event-chart', {
+        category: 'event calc',
+        color: '#758467',
+        defaults: {
+            name: { value: "" },
+            title: { value: "Event Chart" },
+            maxPoints: { value: 200, validate: RED.validators.number() },
+            timestampField: { value: "timestamp" },
+            valueField: { value: "payload" },
+            seriesField: { value: "topic" }
+        },
+        inputs: 1,
+        outputs: 0,
+        icon: "font-awesome/fa-line-chart",
+        paletteLabel: "chart",
+        label: function() {
+            return this.name || this.title || "Event Chart";
+        },
+        labelStyle: function() {
+            return (this.name ? "node_label_italic" : "") + " event-calc-white-text";
+        },
+        oneditprepare: function() {
+            var node = this;
+            var chartInstance = null;
+            var container = document.getElementById('event-chart-preview-container');
+
+            // Create canvas
+            var canvas = document.createElement('canvas');
+            canvas.id = 'event-chart-canvas-' + node.id;
+            canvas.style.width = '100%';
+            canvas.style.height = '100%';
+            container.innerHTML = '';
+            container.appendChild(canvas);
+
+            // Clear button
+            $('#event-chart-clear-btn').on('click', function() {
+                $.post('event-chart/' + node.id + '/clear', function(data) {
+                    if (chartInstance) {
+                        chartInstance.data.datasets = [];
+                        chartInstance.update('none');
+                    }
+                }).fail(function() {
+                    RED.notify("Failed to clear chart", "error");
+                });
+            });
+
+            function loadScript(src) {
+                return new Promise(function(resolve, reject) {
+                    if (document.querySelector('script[src="' + src + '"]')) {
+                        resolve();
+                        return;
+                    }
+                    var script = document.createElement('script');
+                    script.src = src;
+                    script.onload = resolve;
+                    script.onerror = reject;
+                    document.head.appendChild(script);
+                });
+            }
+
+            function initChart() {
+                if (chartInstance) {
+                    chartInstance.destroy();
+                }
+
+                var ctx = document.getElementById('event-chart-canvas-' + node.id);
+                if (!ctx) return;
+
+                chartInstance = new Chart(ctx, {
+                    type: 'line',
+                    data: { datasets: [] },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: false,
+                        animation: false,
+                        scales: {
+                            x: {
+                                type: 'linear',
+                                title: { display: true, text: 'Time' },
+                                ticks: {
+                                    callback: function(value) {
+                                        return new Date(value).toLocaleTimeString();
+                                    }
+                                }
+                            },
+                            y: { title: { display: true, text: 'Value' } }
+                        },
+                        plugins: {
+                            legend: { position: 'top' },
+                            title: { display: true, text: node.title || 'Event Chart' }
+                        }
+                    }
+                });
+
+                // Subscribe to chart data updates
+                RED.comms.subscribe("event-chart-data-" + node.id, function(topic, msg) {
+                    if (chartInstance && msg && msg.data) {
+                        updateChart(msg.data);
+                    }
+                });
+
+                // Load initial data
+                $.getJSON('event-chart/' + node.id + '/data', function(data) {
+                    if (data && data.data) {
+                        updateChart(data.data);
+                    }
+                });
+            }
+
+            function updateChart(data) {
+                if (!chartInstance) return;
+
+                var colors = [
+                    '#2196F3', '#FF5722', '#4CAF50', '#9C27B0',
+                    '#FF9800', '#00BCD4', '#E91E63', '#8BC34A',
+                    '#3F51B5', '#CDDC39', '#009688', '#FFC107'
+                ];
+                var datasets = [];
+                var i = 0;
+                for (var series in data) {
+                    datasets.push({
+                        label: series,
+                        data: data[series],
+                        borderColor: colors[i % colors.length],
+                        backgroundColor: colors[i % colors.length] + '20',
+                        pointRadius: 2,
+                        borderWidth: 2,
+                        tension: 0.1,
+                        fill: false
+                    });
+                    i++;
+                }
+                chartInstance.data.datasets = datasets;
+                chartInstance.update('none');
+            }
+
+            // Load Chart.js
+            if (typeof Chart === 'undefined') {
+                loadScript('https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js')
+                    .then(function() {
+                        setTimeout(initChart, 100);
+                    })
+                    .catch(function(err) {
+                        container.innerHTML = '<p style="color:red">Failed to load Chart.js</p>';
+                    });
+            } else {
+                initChart();
+            }
+        },
+        oneditcancel: function() {
+            RED.comms.unsubscribe("event-chart-data-" + this.id);
+        },
+        oneditsave: function() {
+            RED.comms.unsubscribe("event-chart-data-" + this.id);
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="event-chart">
+    <div class="form-row">
+        <label for="node-input-name"><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-title"><i class="fa fa-header"></i> Title</label>
+        <input type="text" id="node-input-title" placeholder="Event Chart">
+    </div>
+    <div class="form-row">
+        <label for="node-input-valueField"><i class="fa fa-line-chart"></i> Value Field</label>
+        <input type="text" id="node-input-valueField" placeholder="payload">
+    </div>
+    <div class="form-row">
+        <label for="node-input-timestampField"><i class="fa fa-clock-o"></i> Timestamp Field</label>
+        <input type="text" id="node-input-timestampField" placeholder="timestamp">
+    </div>
+    <div class="form-row">
+        <label for="node-input-seriesField"><i class="fa fa-tags"></i> Series Field</label>
+        <input type="text" id="node-input-seriesField" placeholder="topic">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxPoints"><i class="fa fa-database"></i> Max Points</label>
+        <input type="number" id="node-input-maxPoints" placeholder="200">
+    </div>
+    <div class="form-row">
+        <label><i class="fa fa-area-chart"></i> Preview</label>
+        <div id="event-chart-preview-container" style="height: 250px; border: 1px solid #ccc; border-radius: 4px; padding: 5px; background: #fafafa;">
+            <p style="color:#888; text-align:center; padding-top:100px;">Loading chart...</p>
+        </div>
+    </div>
+    <div class="form-row">
+        <button type="button" id="event-chart-clear-btn" class="red-ui-button" style="width: 100%;">
+            <i class="fa fa-trash"></i> Clear Chart Data
+        </button>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-chart">
+    <p>Displays time-series data on an interactive chart.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">number</span></dt>
+        <dd>The value to plot (configurable field name)</dd>
+        <dt class="optional">timestamp <span class="property-type">number</span></dt>
+        <dd>Unix timestamp in ms (defaults to current time)</dd>
+        <dt class="optional">topic <span class="property-type">string</span></dt>
+        <dd>Series name for grouping data (default: "default")</dd>
+    </dl>
+
+    <h3>Properties</h3>
+    <ul>
+        <li><b>Title</b> - Chart title displayed at top</li>
+        <li><b>Value Field</b> - Message property for value (default: payload)</li>
+        <li><b>Timestamp Field</b> - Message property for timestamp</li>
+        <li><b>Series Field</b> - Message property for series name</li>
+        <li><b>Max Points</b> - Maximum points per series (older points removed)</li>
+    </ul>
+
+    <h3>Usage</h3>
+    <p>Connect to any node that outputs numeric data. The chart will automatically:</p>
+    <ul>
+        <li>Group data by series (topic)</li>
+        <li>Display multiple series with different colors</li>
+        <li>Show real-time updates as data arrives</li>
+        <li>Limit data points to prevent memory issues</li>
+    </ul>
+
+    <h3>Clear Data</h3>
+    <p>Use the "Clear Chart Data" button, or send <code>msg.payload = "_clear"</code>.</p>
+
+    <h3>Preview</h3>
+    <p>Double-click the node to see a live preview of the chart with current data.</p>
+</script>

package/nodes/event-chart.js

@@ -0,0 +1,106 @@
+module.exports = function(RED) {
+    function EventChartNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.title = config.title || 'Event Chart';
+        node.maxPoints = parseInt(config.maxPoints) || 200;
+        node.timestampField = config.timestampField || 'timestamp';
+        node.valueField = config.valueField || 'payload';
+        node.seriesField = config.seriesField || 'topic';
+
+        // Store data per series
+        node.chartData = {};
+
+        node.clearChart = function() {
+            node.chartData = {};
+            node.status({ fill: "grey", shape: "ring", text: "cleared" });
+            emitData();
+        };
+
+        node.on('input', function(msg) {
+            // Handle clear command
+            if (msg.payload === '_clear' || msg.topic === '_clear') {
+                node.clearChart();
+                return;
+            }
+
+            const series = RED.util.getMessageProperty(msg, node.seriesField) || 'default';
+            let timestamp = RED.util.getMessageProperty(msg, node.timestampField);
+            let value = RED.util.getMessageProperty(msg, node.valueField);
+
+            // Handle timestamp
+            if (timestamp === undefined || timestamp === null) {
+                timestamp = Date.now();
+            } else if (typeof timestamp !== 'number') {
+                timestamp = new Date(timestamp).getTime();
+            }
+
+            // Handle value
+            if (value === undefined || value === null) {
+                return;
+            }
+
+            if (typeof value !== 'number') {
+                value = parseFloat(value);
+                if (isNaN(value)) return;
+            }
+
+            if (!node.chartData[series]) {
+                node.chartData[series] = [];
+            }
+
+            node.chartData[series].push({
+                x: timestamp,
+                y: value
+            });
+
+            // Limit points per series
+            if (node.chartData[series].length > node.maxPoints) {
+                node.chartData[series].shift();
+            }
+
+            const totalPoints = Object.values(node.chartData).reduce((sum, arr) => sum + arr.length, 0);
+            const seriesCount = Object.keys(node.chartData).length;
+            node.status({ fill: "green", shape: "dot", text: `${seriesCount} series, ${totalPoints} pts` });
+
+            emitData();
+        });
+
+        function emitData() {
+            RED.comms.publish("event-chart-data-" + node.id, {
+                id: node.id,
+                title: node.title,
+                data: node.chartData
+            });
+        }
+
+        node.on('close', function() {
+            node.chartData = {};
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType("event-chart", EventChartNode);
+
+    // Clear chart data endpoint
+    RED.httpAdmin.post("/event-chart/:id/clear", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node && node.clearChart) {
+            node.clearChart();
+            res.sendStatus(200);
+        } else {
+            res.status(404).send("Node not found");
+        }
+    });
+
+    // Get chart data endpoint
+    RED.httpAdmin.get("/event-chart/:id/data", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node) {
+            res.json({ title: node.title, data: node.chartData || {} });
+        } else {
+            res.status(404).send("Node not found");
+        }
+    });
+};

package/nodes/event-in.html

@@ -1,7 +1,12 @@
+<style>
+    .event-calc-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="event-in"] .red-ui-palette-label { color: #ffffff !important; }
+</style>
+
 <script type="text/javascript">
     RED.nodes.registerType('event-in', {
         category: 'event calc',
-        color: '#87CEEB',
+        color: '#758467',
         defaults: {
             name: { value: "" },
             cache: { value: "", type: "event-cache", required: true },
@@ -14,7 +19,8 @@
         label: function() {
             return this.name || "event in";
         },
-        paletteLabel: "event in"
+        paletteLabel: "event in",
+        labelStyle: function() { return (this.name ? "node_label_italic" : "") + " event-calc-white-text"; }
     });
 </script>