simple-graph-query 2.1.0 → 2.1.2

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export declare class SimpleGraphQueryEvaluator {
     datum: IDataInstance;
     forgeListener: ForgeListenerImpl;
     walker: ParseTreeWalker;
+    private parseTreeCache;
     constructor(datum: IDataInstance);
     getExpressionParseTree(forgeExpr: string): import("./forge-antlr/ForgeParser").ParseExprContext;
     evaluateExpression(forgeExpr: string): EvaluationResult;

package/dist/simple-graph-query.bundle.js

@@ -48542,20 +48542,21 @@ function transitiveClosure(pairs) {
         }
         graph.get(from).add(to);
     }
-    // perform BFS from each node to get the transitive closure
+    // Use more efficient BFS with index-based queue to avoid O(n) shift() operations
     // NOTE: we use Set<string> instead of Set<[SingleValue, SingleValue]> since
     // TS would compute equality over the object's reference instead of the value
     // when the value is an array
-    const transitiveClosure = new Set();
+    const transitiveClosureSet = new Set();
     for (const start of graph.keys()) {
         const visited = new Set();
         const queue = [...(graph.get(start) ?? [])];
-        while (queue.length > 0) {
-            const current = queue.shift();
+        let queueIndex = 0; // Use index instead of shift() for O(1) access
+        while (queueIndex < queue.length) {
+            const current = queue[queueIndex++];
             if (visited.has(current))
                 continue;
             visited.add(current);
-            transitiveClosure.add(JSON.stringify([start, current]));
+            transitiveClosureSet.add(JSON.stringify([start, current]));
             const neighbors = graph.get(current);
             if (neighbors) {
                 for (const neighbor of neighbors) {
@@ -48567,7 +48568,7 @@ function transitiveClosure(pairs) {
         }
     }
     // convert the result back to a Tuple[] and return
-    return Array.from(transitiveClosure).map((pair) => JSON.parse(pair));
+    return Array.from(transitiveClosureSet).map((pair) => JSON.parse(pair));
 }
 function dotJoin(left, right) {
     const leftExpr = isSingleValue(left) ? [[left]] : left;
@@ -48685,11 +48686,23 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
     }
     // helper function to get the label as string (used for @: and @str: operators)
     getLabelAsString(value) {
+        // Optimization: for primitive types, convert directly
+        if (typeof value === "number" || typeof value === "boolean") {
+            return String(value);
+        }
         const label = this.getLabelForValue(value);
         return String(label);
     }
     // helper function to get the label as boolean (used for @bool: operator)
     getLabelAsBoolean(value) {
+        // Optimization: for boolean values, return directly
+        if (typeof value === "boolean") {
+            return value;
+        }
+        // Optimization: for number values, apply rule directly
+        if (typeof value === "number") {
+            return value !== 0;
+        }
         const label = this.getLabelForValue(value);
         const labelStr = String(label).toLowerCase();
         // Convert string representations to boolean
@@ -48707,6 +48720,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
     }
     // helper function to get the label as number (used for @num: operator)
     getLabelAsNumber(value) {
+        // Optimization: if value is already a number, return it directly
+        if (typeof value === "number") {
+            return value;
+        }
         const label = this.getLabelForValue(value);
         const labelNum = Number(label);
         if (isNaN(labelNum)) {
@@ -48884,6 +48901,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             const result = [];
             let foundTrue = false;
             let foundFalse = false;
+            // Optimize: create environment once and reuse it
+            const quantDeclEnv = {
+                env: {},
+                type: "quantDecl",
+            };
+            this.environmentStack.push(quantDeclEnv);
             for (let i = 0; i < product.length; i++) {
                 const tuple = product[i];
                 if (isDisjoint) {
@@ -48901,16 +48924,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                         continue;
                     }
                 }
-                const quantDeclEnv = {
-                    env: {},
-                    type: "quantDecl",
-                };
+                // Update environment values in place
                 for (let j = 0; j < varNames.length; j++) {
-                    const varName = varNames[j];
-                    const varValue = tuple[j];
-                    quantDeclEnv.env[varName] = varValue;
+                    quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                this.environmentStack.push(quantDeclEnv);
                 // now, we want to evaluate the barExpr
                 const barExprValue = this.visit(barExpr);
                 if (!isBoolean(barExprValue)) {
@@ -48923,14 +48940,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 else {
                     foundFalse = true;
                 }
-                this.environmentStack.pop();
                 // short-circuit if possible
                 if (ctx.quant().ALL_TOK() && foundFalse) {
+                    this.environmentStack.pop();
                     const value = false;
                     this.cacheResult(ctx, freeVarsKey, value);
                     return value;
                 }
                 if (ctx.quant().NO_TOK() && foundTrue) {
+                    this.environmentStack.pop();
                     const value = false;
                     this.cacheResult(ctx, freeVarsKey, value);
                     return value;
@@ -48938,22 +48956,26 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 if (ctx.quant().mult()) {
                     const multExpr = ctx.quant().mult();
                     if (multExpr.LONE_TOK() && result.length > 1) {
+                        this.environmentStack.pop();
                         const value = false;
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
                     if (multExpr.SOME_TOK() && foundTrue) {
+                        this.environmentStack.pop();
                         const value = true;
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
                     if (multExpr.ONE_TOK() && result.length > 1) {
+                        this.environmentStack.pop();
                         const value = false;
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
                 }
             }
+            this.environmentStack.pop();
             if (ctx.quant().ALL_TOK()) {
                 const value = !foundFalse;
                 this.cacheResult(ctx, freeVarsKey, value);
@@ -49747,7 +49769,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             if (isTupleArray(childrenResults)) {
                 const transitiveClosureResult = transitiveClosure(childrenResults);
                 const idenResult = this.getIden();
-                return deduplicateTuples([...idenResult, ...transitiveClosureResult]);
+                // Optimize: Use Set for efficient deduplication instead of deduplicateTuples
+                const resultSet = new Set();
+                for (const tuple of idenResult) {
+                    resultSet.add(tupleToKey(tuple));
+                }
+                for (const tuple of transitiveClosureResult) {
+                    resultSet.add(tupleToKey(tuple));
+                }
+                return Array.from(resultSet).map(key => JSON.parse(key));
             }
         }
         return childrenResults;
@@ -49872,18 +49902,18 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             }
             const product = getCombinations(quantifiedSets);
             const result = [];
+            // Optimize: create environment once and reuse it
+            const quantDeclEnv = {
+                env: {},
+                type: "quantDecl",
+            };
+            this.environmentStack.push(quantDeclEnv);
             for (let i = 0; i < product.length; i++) {
                 const tuple = product[i];
-                const quantDeclEnv = {
-                    env: {},
-                    type: "quantDecl",
-                };
+                // Update environment values in place
                 for (let j = 0; j < varNames.length; j++) {
-                    const varName = varNames[j];
-                    const varValue = tuple[j];
-                    quantDeclEnv.env[varName] = varValue;
+                    quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                this.environmentStack.push(quantDeclEnv);
                 // now, we want to evaluate the barExpr
                 const barExprValue = this.visit(barExpr);
                 if (!isBoolean(barExprValue)) {
@@ -49893,9 +49923,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     // will error if not boolean val, which we want
                     result.push(tuple);
                 }
-                this.environmentStack.pop();
             }
-            return result;
+            this.environmentStack.pop();
+            // Deduplicate results to ensure set semantics
+            return deduplicateTuples(result);
         }
         if (ctx.LEFT_PAREN_TOK()) {
             // NOTE: we just return the result of evaluating the expr that is inside
@@ -61164,6 +61195,8 @@ class SimpleGraphQueryEvaluator {
     constructor(datum) {
         this.forgeListener = new ForgeListenerImpl_1.ForgeListenerImpl();
         this.walker = new ParseTreeWalker_1.ParseTreeWalker();
+        // Cache for parsed expressions to avoid re-parsing the same expression
+        this.parseTreeCache = new Map();
         this.datum = datum;
     }
     getExpressionParseTree(forgeExpr) {
@@ -61177,18 +61210,28 @@ class SimpleGraphQueryEvaluator {
         return tree;
     }
     evaluateExpression(forgeExpr) {
-        try { // now, we can actually evaluate the expression
-            var tree = this.getExpressionParseTree(forgeExpr);
+        // Check cache first
+        let tree;
+        if (this.parseTreeCache.has(forgeExpr)) {
+            tree = this.parseTreeCache.get(forgeExpr);
         }
-        catch (e) {
-            // if we can't parse the expression, we return an error
-            return {
-                error: new Error(`Error parsing expression "${forgeExpr}"`)
-            };
+        else {
+            try { // now, we can actually evaluate the expression
+                const parsedTree = this.getExpressionParseTree(forgeExpr);
+                tree = parsedTree instanceof ForgeParser_1.ExprContext ? parsedTree : parsedTree.getChild(0);
+                // Cache the parsed tree
+                this.parseTreeCache.set(forgeExpr, tree);
+            }
+            catch (e) {
+                // if we can't parse the expression, we return an error
+                return {
+                    error: new Error(`Error parsing expression "${forgeExpr}"`)
+                };
+            }
         }
         const evaluator = new ForgeExprEvaluator_1.ForgeExprEvaluator(this.datum);
         try {
-            let result = evaluator.visit(tree instanceof ForgeParser_1.ExprContext ? tree : tree.getChild(0));
+            let result = evaluator.visit(tree);
             // ensure we're visiting an ExprContext
             return result;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-graph-query",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",