node-red-contrib-event-calc 3.3.6 → 3.3.15

package/nodes/event-calc.js

@@ -5,7 +5,7 @@
  * - 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
+ * - Cached compiled functions for high throughput
  * - Dynamic expression update via input message
  * - Built-in helper functions for common operations
  */
@@ -16,17 +16,17 @@ module.exports = function(RED) {
         // Math shortcuts
         min: (...args) => Math.min(...args.flat()),
         max: (...args) => Math.max(...args.flat()),
-        abs: (x) => Math.abs(x),
-        sqrt: (x) => Math.sqrt(x),
-        pow: (base, exp) => Math.pow(base, exp),
-        log: (x) => Math.log(x),
-        log10: (x) => Math.log10(x),
-        exp: (x) => Math.exp(x),
-        floor: (x) => Math.floor(x),
-        ceil: (x) => Math.ceil(x),
-        sin: (x) => Math.sin(x),
-        cos: (x) => Math.cos(x),
-        tan: (x) => Math.tan(x),
+        abs: Math.abs,
+        sqrt: Math.sqrt,
+        pow: Math.pow,
+        log: Math.log,
+        log10: Math.log10,
+        exp: Math.exp,
+        floor: Math.floor,
+        ceil: Math.ceil,
+        sin: Math.sin,
+        cos: Math.cos,
+        tan: Math.tan,
         PI: Math.PI,
         E: Math.E,
 
@@ -74,6 +74,11 @@ module.exports = function(RED) {
                 : h >= startHour || h < endHour; // wraps midnight
         }
     };
+
+    // Pre-compute helper keys (shared across all nodes, never changes)
+    const helperKeys = Object.keys(helpers);
+    const helperValues = Object.values(helpers);
+
     function EventCalcNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -111,21 +116,89 @@ module.exports = function(RED) {
             }
         }
 
+        // Subscribe to inputs
+        const latestValues = new Map();
+
+        // Dynamic helpers that need access to cache (created per-node)
+        const cacheHelpers = {
+            now: Date.now,
+            hasChanged: (varName) => {
+                const data = latestValues.get(varName);
+                if (!data || !data.topic) return false;
+                const entry = node.cacheConfig.getValue(data.topic);
+                if (!entry || !entry.previous) return false;
+                return entry.value !== entry.previous.value;
+            },
+            timeSinceLastChange: (varName) => {
+                const data = latestValues.get(varName);
+                if (!data || !data.topic) return 0;
+                const entry = node.cacheConfig.getValue(data.topic);
+                if (!entry) return 0;
+                if (!entry.previous || entry.value === entry.previous.value) {
+                    return Date.now() - (entry.previous ? entry.previous.ts : entry.ts);
+                }
+                return Date.now() - entry.ts;
+            },
+            prev: (varName) => {
+                const data = latestValues.get(varName);
+                if (!data || !data.topic) return undefined;
+                const prev = node.cacheConfig.getPrevious(data.topic);
+                return prev ? prev.value : undefined;
+            }
+        };
+
+        // Pre-compute cache helper keys
+        const cacheHelperKeys = Object.keys(cacheHelpers);
+        const cacheHelperValues = Object.values(cacheHelpers);
+
+        // Pre-compute input variable names (order is stable)
+        const inputNames = node.inputMappings.map(m => m.name);
+
+        // --- Compiled function cache ---
+        // All param names = helpers + cacheHelpers + input variable names
+        // helpers and cacheHelpers are fixed; input names are fixed per node
+        const allParamNames = [...helperKeys, ...cacheHelperKeys, ...inputNames];
+        // Pre-allocate the values array (reused on every call)
+        const allParamValues = new Array(allParamNames.length);
+        // Fill the fixed portion (helpers + cacheHelpers)
+        const fixedCount = helperKeys.length + cacheHelperKeys.length;
+        for (let i = 0; i < helperKeys.length; i++) {
+            allParamValues[i] = helperValues[i];
+        }
+        for (let i = 0; i < cacheHelperKeys.length; i++) {
+            allParamValues[helperKeys.length + i] = cacheHelperValues[i];
+        }
+
+        // Compiled function + expression it was compiled from
+        let compiledFn = null;
+        let compiledExpression = '';
+
+        function compileExpression(expr) {
+            if (expr === compiledExpression && compiledFn) return compiledFn;
+            compiledFn = new Function(...allParamNames, `return ${expr};`);
+            compiledExpression = expr;
+            return compiledFn;
+        }
+
+        // Compile initial expression
+        try {
+            compileExpression(node.expression);
+        } catch (err) {
+            node.status({ fill: "red", shape: "ring", text: "compile error" });
+        }
+
         /**
          * Attempt to calculate and output result
-         * @param {string} triggerTopic - Topic that triggered the calculation
-         * @param {Map} latestValues - Current cached values
-         * @param {number} triggerTs - Timestamp of the triggering event
          */
-        function tryCalculate(triggerTopic, latestValues, triggerTs) {
+        function tryCalculate(triggerTopic, triggerTs) {
             // Ignore updates triggered by our own output
             if (triggerTopic === node.outputTopic) {
                 return;
             }
 
             if (node.triggerOn === 'all') {
-                for (const input of node.inputMappings) {
-                    if (!latestValues.has(input.name)) {
+                for (let i = 0; i < inputNames.length; i++) {
+                    if (!latestValues.has(inputNames[i])) {
                         return;
                     }
                 }
@@ -135,72 +208,45 @@ module.exports = function(RED) {
                 return;
             }
 
-            const context = {};
-            const inputDetails = {};
-            const missingInputs = [];
-
-            for (const input of node.inputMappings) {
-                const data = latestValues.get(input.name);
+            // Fill input variable values into the pre-allocated array
+            let hasAllInputs = true;
+            for (let i = 0; i < inputNames.length; i++) {
+                const data = latestValues.get(inputNames[i]);
                 if (data && data.value !== undefined && data.value !== null) {
-                    context[input.name] = data.value;
-                    inputDetails[input.name] = {
-                        topic: data.topic,
-                        value: data.value,
-                        ts: data.ts
-                    };
+                    allParamValues[fixedCount + i] = data.value;
                 } else {
-                    context[input.name] = undefined;
-                    missingInputs.push(input.name);
+                    allParamValues[fixedCount + i] = undefined;
+                    hasAllInputs = false;
                 }
             }
 
-            // 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 {
-                const allParams = { ...helpers, ...cacheHelpers, ...context };
-                const paramNames = Object.keys(allParams);
-                const paramValues = Object.values(allParams);
-
-                const fn = new Function(...paramNames, `return ${node.expression};`);
-                const result = fn(...paramValues);
+                const fn = compileExpression(node.expression);
+                const result = fn(...allParamValues);
 
                 // Check for NaN or invalid result
                 if (typeof result === 'number' && isNaN(result)) {
-                    const errorMsg = {
+                    node.send([null, {
                         topic: node.outputTopic,
-                        payload: {
-                            error: 'Expression resulted in NaN',
-                            missingInputs: missingInputs,
-                            expression: node.expression
-                        },
+                        payload: { error: 'Expression resulted in NaN', expression: node.expression },
                         trigger: triggerTopic,
                         ts: triggerTs
-                    };
-                    node.send([null, errorMsg]);
+                    }]);
                     node.status({ fill: "yellow", shape: "ring", text: "NaN" });
                     return;
                 }
 
-                const msg = {
+                node.send([{
                     topic: node.outputTopic,
                     payload: result,
                     expression: node.expression,
                     trigger: triggerTopic,
                     ts: triggerTs
-                };
-
-                node.send([msg, null]);
+                }, null]);
 
                 node.cacheConfig.setValue(node.outputTopic, result, {
                     source: 'event-calc',
-                    expression: node.expression,
-                    inputs: Object.keys(inputDetails)
+                    expression: node.expression
                 });
 
                 const resultStr = String(result);
@@ -208,72 +254,16 @@ module.exports = function(RED) {
                 node.status({ fill: "green", shape: "dot", text: `= ${displayResult}` });
 
             } catch (err) {
-                const errorMsg = {
+                node.send([null, {
                     topic: node.outputTopic,
-                    payload: {
-                        error: err.message,
-                        expression: node.expression,
-                        context: context
-                    },
+                    payload: { error: err.message, expression: node.expression },
                     trigger: triggerTopic,
                     ts: triggerTs
-                };
-                node.send([null, errorMsg]);
+                }]);
                 node.status({ fill: "red", shape: "ring", text: "eval error" });
             }
         }
 
-        // Dynamic helpers that need access to cache (created per-node)
-        const cacheHelpers = {
-            /**
-             * now() - Returns current timestamp in milliseconds
-             */
-            now: () => Date.now(),
-
-            /**
-             * hasChanged(varName) - Returns true if the variable's current value
-             * differs from its previous value. Returns false on first message.
-             */
-            hasChanged: (varName) => {
-                const data = latestValues.get(varName);
-                if (!data || !data.topic) return false;
-                const entry = node.cacheConfig.getValue(data.topic);
-                if (!entry || !entry.previous) return false;
-                return entry.value !== entry.previous.value;
-            },
-
-            /**
-             * timeSinceLastChange(varName) - Returns milliseconds since the value
-             * last changed. If never changed, returns time since first message.
-             */
-            timeSinceLastChange: (varName) => {
-                const data = latestValues.get(varName);
-                if (!data || !data.topic) return 0;
-                const entry = node.cacheConfig.getValue(data.topic);
-                if (!entry) return 0;
-                if (!entry.previous || entry.value === entry.previous.value) {
-                    // Value hasn't changed - return time since previous timestamp
-                    // (which is when the last different value was set)
-                    return Date.now() - (entry.previous ? entry.previous.ts : entry.ts);
-                }
-                // Value just changed - return time since this update
-                return Date.now() - entry.ts;
-            },
-
-            /**
-             * prev(varName) - Returns the previous value for a variable
-             */
-            prev: (varName) => {
-                const data = latestValues.get(varName);
-                if (!data || !data.topic) return undefined;
-                const prev = node.cacheConfig.getPrevious(data.topic);
-                return prev ? prev.value : undefined;
-            }
-        };
-
-        // Subscribe to inputs
-        const latestValues = new Map();
-
         for (const input of node.inputMappings) {
             const topicName = input.topic || input.pattern;
             if (!input.name || !topicName) continue;
@@ -284,8 +274,7 @@ module.exports = function(RED) {
                     value: entry.value,
                     ts: entry.ts
                 });
-                // Use the triggering event's timestamp
-                tryCalculate(topic, latestValues, entry.ts);
+                tryCalculate(topic, entry.ts);
             });
             subscriptionIds.push(subId);
         }
@@ -301,15 +290,16 @@ module.exports = function(RED) {
             // Allow expression update via message
             if (msg.expression && typeof msg.expression === 'string') {
                 node.expression = msg.expression;
+                compiledFn = null; // Force recompile
+                compiledExpression = '';
                 node.status({ fill: "blue", shape: "dot", text: "expr updated" });
             }
 
             // External trigger: any incoming message triggers calculation
             if (node.externalTrigger) {
                 const triggerSource = msg.topic || '_external';
-                // Use the incoming message's timestamp or current time
                 const triggerTs = msg.timestamp || Date.now();
-                tryCalculate(triggerSource, latestValues, triggerTs);
+                tryCalculate(triggerSource, triggerTs);
                 done();
                 return;
             }
@@ -318,7 +308,7 @@ module.exports = function(RED) {
             if (msg.payload === 'recalc' || msg.topic === 'recalc') {
                 if (latestValues.size > 0) {
                     const triggerTs = msg.timestamp || Date.now();
-                    tryCalculate('_recalc', latestValues, triggerTs);
+                    tryCalculate('_recalc', triggerTs);
                 }
             }
 

package/nodes/event-frame.html

@@ -0,0 +1,192 @@
+<style>
+    .event-calc-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="event-frame"] .red-ui-palette-label { color: #ffffff !important; }
+</style>
+
+<script type="text/javascript">
+    RED.nodes.registerType('event-frame', {
+        category: 'event calc',
+        color: '#8B6914',
+        defaults: {
+            name: { value: "" },
+            level: { value: "operation" },
+            batchName: { value: "" },
+            batchNameType: { value: "str" },
+            unit: { value: "" },
+            unitType: { value: "str" },
+            batchId: { value: "" },
+            batchIdType: { value: "str" },
+            parentLevel: { value: "" },
+            triggerField: { value: "payload" },
+            metadataField: { value: "" },
+            contextKey: { value: "isa88_batches" },
+            endChildren: { value: true }
+        },
+        inputs: 1,
+        outputs: 2,
+        outputLabels: ["start", "end"],
+        icon: "font-awesome/fa-industry",
+        label: function() {
+            return this.name || this.level || "event frame";
+        },
+        paletteLabel: "event frame",
+        labelStyle: function() { return (this.name ? "node_label_italic" : "") + " event-calc-white-text"; },
+        oneditprepare: function() {
+            var node = this;
+            // Typed inputs for dynamic values
+            $("#node-input-batchName").typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: "#node-input-batchNameType"
+            });
+            $("#node-input-unit").typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: "#node-input-unitType"
+            });
+            $("#node-input-batchId").typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: "#node-input-batchIdType"
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="event-frame">
+    <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-level"><i class="fa fa-sitemap"></i> ISA-88 Level</label>
+        <select id="node-input-level">
+            <option value="procedure">Procedure</option>
+            <option value="unit_procedure">Unit Procedure</option>
+            <option value="operation">Operation</option>
+            <option value="phase">Phase</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-parentLevel"><i class="fa fa-level-up"></i> Parent Level</label>
+        <select id="node-input-parentLevel">
+            <option value="">(none)</option>
+            <option value="procedure">Procedure</option>
+            <option value="unit_procedure">Unit Procedure</option>
+            <option value="operation">Operation</option>
+            <option value="phase">Phase</option>
+        </select>
+        <div class="form-tips">Links this record's <code>parent_id</code> to the currently active record at the selected level.</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-triggerField"><i class="fa fa-bolt"></i> Trigger Field</label>
+        <input type="text" id="node-input-triggerField" placeholder="payload">
+        <div class="form-tips">Message property that is <code>true</code> to start and <code>false</code> to end.</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-batchName"><i class="fa fa-pencil"></i> Batch Name</label>
+        <input type="text" id="node-input-batchName" placeholder="optional">
+        <input type="hidden" id="node-input-batchNameType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-batchId"><i class="fa fa-barcode"></i> Batch ID</label>
+        <input type="text" id="node-input-batchId" placeholder="optional">
+        <input type="hidden" id="node-input-batchIdType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-unit"><i class="fa fa-cube"></i> Unit</label>
+        <input type="text" id="node-input-unit" placeholder="optional">
+        <input type="hidden" id="node-input-unitType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-metadataField"><i class="fa fa-info-circle"></i> Metadata Field</label>
+        <input type="text" id="node-input-metadataField" placeholder="e.g. metadata">
+        <div class="form-tips">Optional <code>msg</code> property containing extra metadata (string or object).</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-contextKey"><i class="fa fa-database"></i> Context Key</label>
+        <input type="text" id="node-input-contextKey" placeholder="isa88_batches">
+        <div class="form-tips">Global context key used to track active batch records across levels.</div>
+    </div>
+    <div class="form-row">
+        <label>&nbsp;</label>
+        <input type="checkbox" id="node-input-endChildren" style="width:auto; margin-right:5px;">
+        <label for="node-input-endChildren" style="width:auto;"> Auto-end children when this frame ends</label>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-frame">
+    <p>Creates ISA-88 batch structure records with start/end tracking.</p>
+
+    <h3>ISA-88 Procedural Model</h3>
+    <p>The ISA-88 standard defines a hierarchical procedural model:</p>
+    <ul>
+        <li><b>Procedure</b> — top-level batch recipe</li>
+        <li><b>Unit Procedure</b> — sequence within a unit</li>
+        <li><b>Operation</b> — major processing step</li>
+        <li><b>Phase</b> — lowest-level action</li>
+    </ul>
+
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>ISA-88 Level</dt>
+        <dd>The procedural level of this batch record.</dd>
+        <dt>Parent Level</dt>
+        <dd>Optional. Links <code>parent_id</code> to the currently active record at the selected level.
+        Not needed when chaining — <code>msg.frame_id</code> from a parent node is used automatically.</dd>
+        <dt>Trigger Field</dt>
+        <dd>Message property: truthy starts, falsy ends the record.</dd>
+        <dt>Batch Name / Batch ID / Unit</dt>
+        <dd>Optional fields — can be static strings, msg properties, flow/global context, or env vars.</dd>
+        <dt>Metadata Field</dt>
+        <dd>Optional msg property for extra metadata (stored as string).</dd>
+        <dt>Context Key</dt>
+        <dd>Global context key for tracking active records (default: <code>isa88_batches</code>).</dd>
+        <dt>Auto-end children</dt>
+        <dd>When enabled (default), ending this frame automatically ends all child frames whose <code>parent_id</code> matches this frame's ID. Cascades recursively.</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <p>Any message. The trigger field determines start/end:</p>
+    <ul>
+        <li><b>Truthy</b> (and no active record): starts a new batch record</li>
+        <li><b>Falsy</b> (and record is active): ends the current record</li>
+    </ul>
+
+    <h3>Outputs</h3>
+    <ol>
+        <li><b>Start</b> — emits when a new batch record begins</li>
+        <li><b>End</b> — emits the completed record with <code>endtime</code> filled in</li>
+    </ol>
+
+    <h3>Output Record</h3>
+    <pre>{
+  "id": "auto-generated UUID",
+  "starttime": "2024-01-15T10:30:00.000Z",
+  "endtime": "9999-12-31T23:59:59.000Z",
+  "name": "Mixing",
+  "parent_id": "parent-uuid-or-empty",
+  "level": "operation",
+  "state": "complete",
+  "batch_id": "BATCH-001",
+  "unit": "Reactor-1",
+  "metadata": ""
+}</pre>
+
+    <h3>Chaining</h3>
+    <p>Wire the <b>Start</b> output of a parent frame to the input of a child frame.
+    The start message carries <code>msg.frame_id</code> which the child automatically
+    uses as its <code>parent_id</code>. No need to set Parent Level when chaining.</p>
+    <pre>
+  [Procedure] ──start──► [Operation] ──start──► [Phase]
+    </pre>
+    <p>When <b>Auto-end children</b> is enabled, ending the Procedure will automatically
+    end the Operation, which in turn ends the Phase (recursive cascade).</p>
+
+    <h3>Details</h3>
+    <p>Use one node per ISA-88 level. Link them by wiring start outputs to child inputs,
+    or set <b>Parent Level</b> for lookup-based linking.</p>
+
+    <p>Multiple instances sharing the same <b>Context Key</b> can coordinate
+    across the hierarchy.</p>
+</script>