simple-graph-query 2.0.1 → 2.1.0

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

@@ -48473,11 +48473,17 @@ function extractNumber(val) {
 function isString(value) {
     return typeof value === "string";
 }
+// Helper to create a string key from a tuple for fast lookup
+function tupleToKey(tuple) {
+    return JSON.stringify(tuple);
+}
 function areTuplesEqual(a, b) {
     return a.length === b.length && a.every((val, i) => val === b[i]);
 }
 function isTupleArraySubset(a, b) {
-    return a.every((tupleA) => b.some((tupleB) => areTuplesEqual(tupleA, tupleB)));
+    // Optimize using Set for O(n) lookup instead of O(n²)
+    const bSet = new Set(b.map(tupleToKey));
+    return a.every((tupleA) => bSet.has(tupleToKey(tupleA)));
 }
 function areTupleArraysEqual(a, b) {
     if (a.length !== b.length) {
@@ -48486,9 +48492,13 @@ function areTupleArraysEqual(a, b) {
     return isTupleArraySubset(a, b) && isTupleArraySubset(b, a);
 }
 function deduplicateTuples(tuples) {
+    // Optimize using Set for O(n) deduplication instead of O(n²)
+    const seen = new Set();
     const result = [];
     for (const tuple of tuples) {
-        if (!result.some((existing) => areTuplesEqual(existing, tuple))) {
+        const key = tupleToKey(tuple);
+        if (!seen.has(key)) {
+            seen.add(key);
             result.push(tuple);
         }
     }
@@ -48497,15 +48507,23 @@ function deduplicateTuples(tuples) {
 function getCombinations(arrays) {
     // first, turn each string[][] into a string[] by flattening
     const valueSets = arrays.map((tuple) => tuple.flat());
-    // now, recursively compute the cartesian product
-    function cartesianProduct(arrays) {
-        if (arrays.length === 0)
-            return [[]];
-        const [first, ...rest] = arrays;
-        const restProduct = cartesianProduct(rest);
-        return first.flatMap((value) => restProduct.map((product) => [value, ...product]));
+    // Early exit for empty arrays
+    if (valueSets.length === 0)
+        return [[]];
+    if (valueSets.some(arr => arr.length === 0))
+        return [];
+    // Iterative approach for better performance on large cartesian products
+    let result = [[]];
+    for (const valueSet of valueSets) {
+        const newResult = [];
+        for (const existing of result) {
+            for (const value of valueSet) {
+                newResult.push([...existing, value]);
+            }
+        }
+        result = newResult;
     }
-    return cartesianProduct(valueSets);
+    return result;
 }
 function transitiveClosure(pairs) {
     if (pairs.length === 0)
@@ -48554,17 +48572,29 @@ function transitiveClosure(pairs) {
 function dotJoin(left, right) {
     const leftExpr = isSingleValue(left) ? [[left]] : left;
     const rightExpr = isSingleValue(right) ? [[right]] : right;
+    // Optimize join using a Map for O(n+m) instead of O(n*m) lookup
+    // Group right tuples by their first element for fast lookup
+    const rightIndex = new Map();
+    for (const rightTuple of rightExpr) {
+        const key = rightTuple[0];
+        if (!rightIndex.has(key)) {
+            rightIndex.set(key, []);
+        }
+        rightIndex.get(key).push(rightTuple);
+    }
     const result = [];
-    leftExpr.forEach((leftTuple) => {
-        rightExpr.forEach((rightTuple) => {
-            if (leftTuple[leftTuple.length - 1] === rightTuple[0]) {
+    for (const leftTuple of leftExpr) {
+        const joinKey = leftTuple[leftTuple.length - 1];
+        const matchingRightTuples = rightIndex.get(joinKey);
+        if (matchingRightTuples) {
+            for (const rightTuple of matchingRightTuples) {
                 result.push([
                     ...leftTuple.slice(0, leftTuple.length - 1),
                     ...rightTuple.slice(1),
                 ]);
             }
-        });
-    });
+        }
+    }
     if (result.some(tuple => tuple.length === 0)) {
         throw new Error("Join would create a relation of arity 0");
     }
@@ -48628,7 +48658,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
     constructFreeVariableKey(freeVarValues) {
         const keys = Object.keys(freeVarValues);
         keys.sort(); // sort the keys to ensure consistent ordering
-        return keys.map((key) => `${key}=${freeVarValues[key]}`).join("|");
+        // Use JSON.stringify for complex values to ensure proper serialization
+        return keys.map((key) => {
+            const value = freeVarValues[key];
+            const valueStr = Array.isArray(value) ? JSON.stringify(value) : String(value);
+            return `${key}=${valueStr}`;
+        }).join("|");
     }
     // helper function to get the label for a value (used for @: operator)
     getLabelForValue(value) {
@@ -49418,7 +49453,9 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return leftChildValue;
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    return leftChildValue.filter((tuple) => !rightChildValue.some((rightTuple) => areTuplesEqual(tuple, rightTuple)));
+                    // Optimize set difference using Set for O(n+m) instead of O(n*m)
+                    const rightSet = new Set(rightChildValue.map(tupleToKey));
+                    return leftChildValue.filter(tuple => !rightSet.has(tupleToKey(tuple)));
                 }
             }
             else {
@@ -49491,7 +49528,9 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return [];
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    return leftChildValue.filter((tuple) => rightChildValue.some((rightTuple) => areTuplesEqual(tuple, rightTuple)));
+                    // Optimize set intersection using Set for O(n+m) instead of O(n*m)
+                    const rightSet = new Set(rightChildValue.map(tupleToKey));
+                    return leftChildValue.filter(tuple => rightSet.has(tupleToKey(tuple)));
                 }
             }
             else {
@@ -50025,12 +50064,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         if (exports.SUPPORTED_BUILTINS.includes(identifier)) {
             return identifier;
         }
-        // Check if this looks like a simple label identifier (for label comparison)
-        // Heuristic: simple lowercase words that look like color/state names
-        const labelLikePattern = /^[a-z]{3,10}$/; // 3-10 lowercase letters only
+        // Check if this looks like a label identifier (for label comparison).
+        // Labels can be any alphanumeric string with underscores.
+        // This allows identifiers like "Black", "red", "my_label", "Color_123", etc.
+        // to be treated as string literals in label comparisons (e.g., @:y = Black).
+        const labelLikePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
         if (labelLikePattern.test(identifier)) {
-            // This looks like a simple label (e.g., "black", "red", "blue", etc.)
-            // Return it as a string literal to enable label comparison syntax
             return identifier;
         }
         throw new NameNotFoundError(`bad name ${identifier} referenced!`);

package/package.json

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