simple-graph-query 2.4.0 → 2.5.0

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

@@ -51022,8 +51022,7 @@ function normalizeBinaryResult(result) {
     }
     return ids;
 }
-function evaluateExpression(node, datum, normalizer) {
-    const evaluator = new index_1.SimpleGraphQueryEvaluator(datum);
+function evaluateExpression(node, evaluator, normalizer) {
     const expression = nodeToString(node);
     const result = evaluator.evaluateExpression(expression);
     return normalizer(result);
@@ -51055,15 +51054,52 @@ function setsEqual(a, b) {
     }
     return true;
 }
+function classifyIdentifier(name, datums) {
+    if (name === "univ" || name === "iden") {
+        return "builtin";
+    }
+    for (const datum of datums) {
+        if (datum.getRelations().some((relation) => relation.name === name)) {
+            return "relation";
+        }
+        if (datum.getTypes().some((type) => type.id === name)) {
+            return "type";
+        }
+    }
+    return "other";
+}
 function buildBaseNodes(datums) {
     const baseNames = intersectNames(datums);
     // Always include standard top-level identifiers when present in the language
     ["univ", "iden"].forEach((builtin) => baseNames.add(builtin));
-    return Array.from(baseNames).map((name) => ({ kind: "identifier", name }));
+    const orderedNames = Array.from(baseNames).sort((left, right) => {
+        const priority = {
+            relation: 0,
+            type: 1,
+            builtin: 2,
+            other: 3,
+        };
+        const leftPriority = priority[classifyIdentifier(left, datums)];
+        const rightPriority = priority[classifyIdentifier(right, datums)];
+        if (leftPriority !== rightPriority) {
+            return leftPriority - rightPriority;
+        }
+        return left.localeCompare(right);
+    });
+    return orderedNames.map((name) => ({ kind: "identifier", name }));
+}
+function getOrCreateEvaluator(datum, cache) {
+    const existing = cache.get(datum);
+    if (existing) {
+        return existing;
+    }
+    const evaluator = new index_1.SimpleGraphQueryEvaluator(datum);
+    cache.set(datum, evaluator);
+    return evaluator;
 }
 function matchesTargets(node, examples, normalizer) {
     for (const example of examples) {
-        const result = evaluateExpression(node, example.datum, normalizer);
+        const result = evaluateExpression(node, example.evaluator, normalizer);
         if (!result)
             return false;
         if (!setsEqual(result, example.target)) {
@@ -51079,11 +51115,21 @@ function synthesizeExpressionNode(examples, normalizer, maxDepth = 3) {
     if (examples.length === 0) {
         throw new SelectorSynthesisError("No examples provided for synthesis");
     }
-    const datums = examples.map((example) => example.datum);
+    const evaluatorCache = new Map();
+    const evaluatedExamples = examples.map((example) => ({
+        ...example,
+        evaluator: getOrCreateEvaluator(example.datum, evaluatorCache),
+    }));
+    const datums = evaluatedExamples.map((example) => example.datum);
     const baseNodes = buildBaseNodes(datums);
     if (baseNodes.length === 0) {
         throw new SelectorSynthesisError("No shared identifiers available across provided data instances");
     }
+    for (const node of baseNodes) {
+        if (matchesTargets(node, evaluatedExamples, normalizer)) {
+            return node;
+        }
+    }
     const queue = [];
     const queued = new Set();
     const visited = new Set();
@@ -51104,7 +51150,7 @@ function synthesizeExpressionNode(examples, normalizer, maxDepth = 3) {
             continue;
         }
         visited.add(key);
-        if (matchesTargets(current.node, examples, normalizer)) {
+        if (matchesTargets(current.node, evaluatedExamples, normalizer)) {
             return current.node;
         }
         if (current.depth >= maxDepth) {
@@ -51141,8 +51187,8 @@ function synthesizeBinaryRelation(examples, maxDepth = 3) {
     const node = synthesizeExpressionNode(synthesisExamples, normalizeBinaryResult, maxDepth);
     return nodeToString(node);
 }
-function buildWhyNode(node, datum, normalizer) {
-    const result = evaluateExpression(node, datum, normalizer);
+function buildWhyNode(node, evaluator, normalizer) {
+    const result = evaluateExpression(node, evaluator, normalizer);
     const base = {
         kind: node.kind,
         expression: nodeToString(node),
@@ -51152,7 +51198,7 @@ function buildWhyNode(node, datum, normalizer) {
         case "identifier":
             return base;
         case "closure":
-            return { ...base, children: [buildWhyNode(node.child, datum, normalizer)] };
+            return { ...base, children: [buildWhyNode(node.child, evaluator, normalizer)] };
         case "join":
         case "union":
         case "intersection":
@@ -51160,8 +51206,8 @@ function buildWhyNode(node, datum, normalizer) {
             return {
                 ...base,
                 children: [
-                    buildWhyNode(node.left, datum, normalizer),
-                    buildWhyNode(node.right, datum, normalizer),
+                    buildWhyNode(node.left, evaluator, normalizer),
+                    buildWhyNode(node.right, evaluator, normalizer),
                 ],
             };
         default:
@@ -51175,12 +51221,16 @@ function synthesizeSelectorWithWhy(examples, maxDepth = 3) {
     }));
     const node = synthesizeExpressionNode(synthesisExamples, normalizeUnaryResult, maxDepth);
     const expression = nodeToString(node);
-    const explanationExamples = synthesisExamples.map((example) => ({
-        datum: example.datum,
-        target: example.target,
-        result: evaluateExpression(node, example.datum, normalizeUnaryResult),
-        why: buildWhyNode(node, example.datum, normalizeUnaryResult),
-    }));
+    const evaluatorCache = new Map();
+    const explanationExamples = synthesisExamples.map((example) => {
+        const evaluator = getOrCreateEvaluator(example.datum, evaluatorCache);
+        return {
+            datum: example.datum,
+            target: example.target,
+            result: evaluateExpression(node, evaluator, normalizeUnaryResult),
+            why: buildWhyNode(node, evaluator, normalizeUnaryResult),
+        };
+    });
     return { expression, examples: explanationExamples };
 }
 function synthesizeBinaryRelationWithWhy(examples, maxDepth = 3) {
@@ -51190,12 +51240,16 @@ function synthesizeBinaryRelationWithWhy(examples, maxDepth = 3) {
     });
     const node = synthesizeExpressionNode(synthesisExamples, normalizeBinaryResult, maxDepth);
     const expression = nodeToString(node);
-    const explanationExamples = synthesisExamples.map((example) => ({
-        datum: example.datum,
-        target: example.target,
-        result: evaluateExpression(node, example.datum, normalizeBinaryResult),
-        why: buildWhyNode(node, example.datum, normalizeBinaryResult),
-    }));
+    const evaluatorCache = new Map();
+    const explanationExamples = synthesisExamples.map((example) => {
+        const evaluator = getOrCreateEvaluator(example.datum, evaluatorCache);
+        return {
+            datum: example.datum,
+            target: example.target,
+            result: evaluateExpression(node, evaluator, normalizeBinaryResult),
+            why: buildWhyNode(node, evaluator, normalizeBinaryResult),
+        };
+    });
     return { expression, examples: explanationExamples };
 }
 

package/package.json

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