@halleyassist/rule-parser 1.0.25 → 1.0.26

package/dist/rule-parser.browser.js

@@ -1949,6 +1949,31 @@ const LogicalOperators = {
     '||': 'Or',
     'OR': 'Or'
 };
+const ILReservedNames = new Set([
+    'Value',
+    'Array',
+    'ArrayIn',
+    'Between',
+    'Not',
+    'And',
+    'Or',
+    'Gt',
+    'Lt',
+    'Gte',
+    'Lte',
+    'Eq',
+    'Neq',
+    'MathAdd',
+    'MathSub',
+    'MathDiv',
+    'MathMul',
+    'MathMod',
+    'Default',
+    'TimePeriodConst',
+    'TimePeriodConstAgo',
+    'TimePeriodBetween',
+    'TimePeriodBetweenAgo'
+]);
 const DOW_MAP = {
     'MON': 'MONDAY',
     'TUE': 'TUESDAY',
@@ -2609,6 +2634,29 @@ class RuleParser {
             throw new Error(`unknown type of expression ${ eInner.type }`);
         }
     }
+    static _collectFunctions(il, names) {
+        if (!Array.isArray(il) || il.length === 0) {
+            return;
+        }
+        const [head, ...tail] = il;
+        if (typeof head === 'string') {
+            if (!ILReservedNames.has(head)) {
+                names.add(head);
+            }
+            for (const child of tail) {
+                RuleParser._collectFunctions(child, names);
+            }
+            return;
+        }
+        for (const child of il) {
+            RuleParser._collectFunctions(child, names);
+        }
+    }
+    static getFunctions(il) {
+        const names = new Set();
+        RuleParser._collectFunctions(il, names);
+        return [...names];
+    }
     static toIL(txt) {
         try {
             const ast = RuleParser.toAst(txt);

package/index.d.ts

@@ -127,12 +127,24 @@ export type TimePeriodExpression =
   | TimePeriodBetween 
   | TimePeriodBetweenAgo;
 
+/**
+ * Array expression used for dynamic `IN (...)` arguments
+ */
+export type ArrayExpression = ['Array', ...ILExpression[]];
+
+/**
+ * Array membership expression
+ */
+export type ArrayInExpression = ['ArrayIn', ILExpression, ILExpression];
+
 /**
  * Forward declaration for ILExpression to handle recursive types
  */
 export type ILExpression = 
   | ValueExpression
   | TimePeriodExpression
+  | ArrayExpression
+  | ArrayInExpression
   | FunctionCall
   | ComparisonExpression
   | LogicalExpression
@@ -207,6 +219,13 @@ declare class RuleParser {
    * @throws {RuleParseError} If the rule string is invalid
    */
   static toIL(txt: string): ILExpression;
+
+  /**
+   * Collect unique function names referenced in an IL expression
+   * @param il - The IL expression to inspect
+   * @returns Unique function names in first-seen order
+   */
+  static getFunctions(il: ILExpression): string[];
 }
 
 export default RuleParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-parser",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleParser.production.js",
   "browser": "./dist/rule-parser.browser.js",

package/src/RuleParser.js

@@ -34,6 +34,32 @@ const LogicalOperators = {
     "OR": 'Or',
 }
 
+const ILReservedNames = new Set([
+    'Value',
+    'Array',
+    'ArrayIn',
+    'Between',
+    'Not',
+    'And',
+    'Or',
+    'Gt',
+    'Lt',
+    'Gte',
+    'Lte',
+    'Eq',
+    'Neq',
+    'MathAdd',
+    'MathSub',
+    'MathDiv',
+    'MathMul',
+    'MathMod',
+    'Default',
+    'TimePeriodConst',
+    'TimePeriodConstAgo',
+    'TimePeriodBetween',
+    'TimePeriodBetweenAgo'
+])
+
 // Map abbreviations to canonical uppercase full form
 const DOW_MAP = {
     'MON': 'MONDAY',
@@ -623,6 +649,32 @@ class RuleParser {
                 throw new Error(`unknown type of expression ${eInner.type}`)
         }
     }
+    static _collectFunctions(il, names){
+        if(!Array.isArray(il) || il.length === 0){
+            return
+        }
+
+        const [head, ...tail] = il
+
+        if(typeof head === 'string'){
+            if(!ILReservedNames.has(head)){
+                names.add(head)
+            }
+            for(const child of tail){
+                RuleParser._collectFunctions(child, names)
+            }
+            return
+        }
+
+        for(const child of il){
+            RuleParser._collectFunctions(child, names)
+        }
+    }
+    static getFunctions(il){
+        const names = new Set()
+        RuleParser._collectFunctions(il, names)
+        return [...names]
+    }
     static toIL(txt){
         try {
             const ast = RuleParser.toAst(txt)

package/src/RuleParser.production.js

@@ -34,6 +34,32 @@ const LogicalOperators = {
     "OR": 'Or',
 }
 
+const ILReservedNames = new Set([
+    'Value',
+    'Array',
+    'ArrayIn',
+    'Between',
+    'Not',
+    'And',
+    'Or',
+    'Gt',
+    'Lt',
+    'Gte',
+    'Lte',
+    'Eq',
+    'Neq',
+    'MathAdd',
+    'MathSub',
+    'MathDiv',
+    'MathMul',
+    'MathMod',
+    'Default',
+    'TimePeriodConst',
+    'TimePeriodConstAgo',
+    'TimePeriodBetween',
+    'TimePeriodBetweenAgo'
+])
+
 // Map abbreviations to canonical uppercase full form
 const DOW_MAP = {
     'MON': 'MONDAY',
@@ -623,6 +649,32 @@ class RuleParser {
                 throw new Error(`unknown type of expression ${eInner.type}`)
         }
     }
+    static _collectFunctions(il, names){
+        if(!Array.isArray(il) || il.length === 0){
+            return
+        }
+
+        const [head, ...tail] = il
+
+        if(typeof head === 'string'){
+            if(!ILReservedNames.has(head)){
+                names.add(head)
+            }
+            for(const child of tail){
+                RuleParser._collectFunctions(child, names)
+            }
+            return
+        }
+
+        for(const child of il){
+            RuleParser._collectFunctions(child, names)
+        }
+    }
+    static getFunctions(il){
+        const names = new Set()
+        RuleParser._collectFunctions(il, names)
+        return [...names]
+    }
     static toIL(txt){
         try {
             const ast = RuleParser.toAst(txt)