simple-graph-query 2.2.1 → 2.3.0

package/dist/ForgeExprEvaluator.d.ts

@@ -27,6 +27,9 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     private getLabelAsString;
     private getLabelAsBoolean;
     private getLabelAsNumber;
+    private isConvertibleToNumber;
+    private isConvertibleToBoolean;
+    private convertToBoolean;
     private dotJoin;
     private cacheResult;
     private getIden;

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

@@ -48619,28 +48619,11 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         this.relationCache = new Map();
         this.relationIndexCache = new Map();
         const relations = this.instanceData.getRelations();
-        const isConvertibleToNumber = (value) => {
-            return typeof value === "string" && !isNaN(Number(value));
-        };
-        const isConvertibleToBoolean = (value) => {
-            if (typeof value === "boolean")
-                return false; // already boolean
-            return value === "true" || value === "#t" || value === "false" || value === "#f";
-        };
-        const convertToBoolean = (value) => {
-            if (typeof value === "boolean")
-                return value;
-            if (value === "true" || value === "#t")
-                return true;
-            if (value === "false" || value === "#f")
-                return false;
-            throw new Error(`Cannot convert ${value} to boolean`);
-        };
         for (const relation of relations) {
             let relationAtoms = relation.tuples.map((tuple) => tuple.atoms);
             // Convert numeric and boolean strings to their actual types
-            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
-            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.convertToBoolean(value) : value));
             this.relationCache.set(relation.name, relationAtoms);
             // Build index for this relation: first element -> all tuples starting with that element
             const relationIndex = new Map();
@@ -48751,6 +48734,39 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         }
         return labelNum;
     }
+    // Helper function to check if a value can be converted to a number
+    isConvertibleToNumber(value) {
+        if (typeof value === "number") {
+            return true;
+        }
+        if (typeof value === "string") {
+            return !isNaN(Number(value));
+        }
+        return false;
+    }
+    // Helper function to check if a value can be converted to a boolean
+    isConvertibleToBoolean(value) {
+        if (typeof value === "boolean") {
+            return true;
+        }
+        if (typeof value === "string") {
+            return (value === "true" || value === "#t" || value === "false" || value === "#f");
+        }
+        return false;
+    }
+    // Helper function to convert a value to boolean
+    convertToBoolean(value) {
+        if (typeof value === "boolean") {
+            return value;
+        }
+        if (value === "true" || value === "#t") {
+            return true;
+        }
+        if (value === "false" || value === "#f") {
+            return false;
+        }
+        throw new Error(`Cannot convert ${value} to boolean`);
+    }
     // Optimized dotJoin that can use pre-built relation indexes
     dotJoin(left, right, rightRelationName) {
         const leftExpr = isSingleValue(left) ? [[left]] : left;
@@ -49953,6 +49969,42 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 // }
                 return value;
             }
+            // Handle iden (identity relation)
+            if (constant.IDEN_TOK() !== undefined) {
+                // The identity relation contains tuples (x, x) for every atom x in the universe
+                const atoms = this.instanceData.getAtoms();
+                const idenRelation = [];
+                for (const atom of atoms) {
+                    let atomValue = atom.id;
+                    // Convert numeric and boolean strings to their actual types
+                    if (this.isConvertibleToNumber(atomValue)) {
+                        atomValue = Number(atomValue);
+                    }
+                    else if (this.isConvertibleToBoolean(atomValue)) {
+                        atomValue = this.convertToBoolean(atomValue);
+                    }
+                    idenRelation.push([atomValue, atomValue]);
+                }
+                return idenRelation;
+            }
+            // Handle univ (universal relation - all atoms)
+            if (constant.UNIV_TOK() !== undefined) {
+                // The universal relation contains all atoms as unary tuples
+                const atoms = this.instanceData.getAtoms();
+                const univRelation = [];
+                for (const atom of atoms) {
+                    let atomValue = atom.id;
+                    // Convert numeric and boolean strings to their actual types
+                    if (this.isConvertibleToNumber(atomValue)) {
+                        atomValue = Number(atomValue);
+                    }
+                    else if (this.isConvertibleToBoolean(atomValue)) {
+                        atomValue = this.convertToBoolean(atomValue);
+                    }
+                    univRelation.push([atomValue]);
+                }
+                return univRelation;
+            }
             // Handle boolean constants
             if (constant.text === 'true') {
                 return true;
@@ -50184,46 +50236,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 }
             }
         }
-        // defining 3 helper functions here; not for use elsewhere
-        const isConvertibleToNumber = (value) => {
-            if (typeof value === "number") {
-                return true;
-            }
-            if (typeof value === "string") {
-                return !isNaN(Number(value));
-            }
-            return false;
-        };
-        const isConvertibleToBoolean = (value) => {
-            if (typeof value === "boolean") {
-                return true;
-            }
-            if (typeof value === "string") {
-                return (value === "true" || value === "#t" || value === "false" || value === "#f");
-            }
-            return false;
-        };
-        const convertToBoolean = (value) => {
-            if (typeof value === "boolean") {
-                return value;
-            }
-            if (value === "true" || value === "#t") {
-                return true;
-            }
-            if (value === "false" || value === "#f") {
-                return false;
-            }
-            throw new Error(`Cannot convert ${value} to boolean`);
-        };
-        // end of 3 helper functions
+        // end of type search
         // check if it is a relation - use cache for faster lookups
         this.buildRelationCache();
         if (this.relationCache.has(identifier)) {
             return this.relationCache.get(identifier);
         }
         if (result !== undefined) {
-            result = result.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
-            result = result.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
+            result = result.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
+            result = result.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.convertToBoolean(value) : value));
             return result;
         }
         // return identifier;

package/package.json

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