@halleyassist/rule-templater 0.0.5 → 0.0.6

package/README.md

@@ -31,6 +31,11 @@ console.log(variables);
 //   { name: 'THRESHOLD', filters: [], positions: [{ start: 36, end: 48 }] }
 // ]
 
+// Extract function calls from the template
+const functions = parsed.extractFunctions();
+console.log(functions);
+// ['EventIs', 'Value']
+
 // Validate that variables are provided correctly
 const validation = parsed.validate({
     EVENT_TYPE: { value: 'sensor-update', type: 'string' },
@@ -160,6 +165,23 @@ Extracts all variables from the template using the AST.
 
 Note: If a variable appears multiple times in the template, all occurrences will be recorded in the `positions` array.
 
+### `ruleTemplate.extractFunctions()`
+
+Extracts all function calls from the template using the AST.
+
+**Returns:** Array of unique function names (sorted alphabetically) used in the template.
+
+**Example:**
+```javascript
+const template = 'EventIs("test") && Value() > 10 && TimeLastTrueCheck("last_check") < 60';
+const parsed = RuleTemplate.parse(template);
+const functions = parsed.extractFunctions();
+console.log(functions);
+// ['EventIs', 'TimeLastTrueCheck', 'Value']
+```
+
+This is useful for comparing against a hub's list of available functions to ensure all functions used in the template are supported.
+
 ### `ruleTemplate.validate(variables)`
 
 Validates that all required variables are provided and have valid types.

package/dist/rule-templater.browser.js

@@ -2165,6 +2165,39 @@ class RuleTemplate {
         return variables;
     }
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
     /**
      * Extract variable name and filters from a template_value AST node
      * @private

package/index.d.ts

@@ -68,6 +68,12 @@ export default class RuleTemplate {
      */
     extractVariables(): VariableInfo[];
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns Array of unique function names used in the template
+     */
+    extractFunctions(): string[];
+
     /**
      * Validate variable types against the AST
      * @param variables Object mapping variable names to {value, type} objects

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-templater",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleTemplater.production.js",
   "browser": "./dist/rule-templater.browser.js",

package/src/RuleTemplater.js

@@ -127,6 +127,39 @@ class RuleTemplate {
         return variables;
     }
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
     /**
      * Extract variable name and filters from a template_value AST node
      * @private

package/src/RuleTemplater.production.js

@@ -127,6 +127,39 @@ class RuleTemplate {
         return variables;
     }
 
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
     /**
      * Extract variable name and filters from a template_value AST node
      * @private