vega2ol 1.1.1 → 1.1.3

package/dist/main.js

@@ -19,8 +19,6 @@ const OPERATOR_MAPPING = {
     "*": "*",
     "/": "/",
     "%": "%",
-    // Other
-    "**": "pow",
 };
 /**
  * Constants mapping from Vega constants to OpenLayers constants
@@ -47,30 +45,12 @@ const FUNCTION_MAPPING = {
     ceil: "ceil",
     round: "round",
     sqrt: "sqrt",
-    pow: "pow",
-    log: "log",
-    exp: "exp",
+    pow: "^",
     sin: "sin",
     cos: "cos",
-    tan: "tan",
-    // String functions
-    tostring: "toString",
-    upper: "toUpperCase",
-    lower: "toLowerCase",
-    substring: "substring",
-    // Array functions
-    length: "length",
-    indexof: "indexOf",
-    slice: "slice",
-    // Type functions
-    type: "type",
-    isvalid: "isValid",
-    isnumber: "isNumber",
-    isstring: "isString",
-    isboolean: "isBoolean",
-    // Aggregation functions
-    min: "min",
-    max: "max",
+    atan: "atan",
+    atan2: "atan",
+    clamp: "clamp",
 };
 /**
  * Custom error class for Vega2OL transpilation errors
@@ -89,6 +69,20 @@ class VegaToOLVisitor {
     constructor() {
         this.scope = {};
     }
+    isNegativeOne(node) {
+        // Case 1: Literal -1
+        if (node.type === "Literal" && node.value === -1) {
+            return true;
+        }
+        // Case 2: UnaryExpression: -1
+        if (node.type === "UnaryExpression" &&
+            node.operator === "-" &&
+            node.argument?.type === "Literal" &&
+            node.argument.value === 1) {
+            return true;
+        }
+        return false;
+    }
     visit(node) {
         if (!node || !node.type) {
             throw new Vega2OLError("Invalid AST node");
@@ -128,9 +122,44 @@ class VegaToOLVisitor {
         }
         throw new Vega2OLError(`Unsupported member access`);
     }
+    isIndexOfCall(node) {
+        return (node.type === "CallExpression" &&
+            node.callee?.type === "Identifier" &&
+            node.callee.name.toLowerCase() === "indexof");
+    }
     // Binary operations: a + b, a > b, etc.
     visitBinaryExpression(node) {
         const { operator, left, right } = node;
+        // Special handling for indexOf comparisons
+        if (operator === "!=" || operator === "==") {
+            let call = null;
+            if (this.isIndexOfCall(left) && this.isNegativeOne(right)) {
+                call = left;
+            }
+            else if (this.isIndexOfCall(right) && this.isNegativeOne(left)) {
+                call = right;
+            }
+            if (call) {
+                const [arrayArg, valueArg] = call.arguments || [];
+                if (arrayArg && valueArg) {
+                    const arrayOL = this.visit(arrayArg);
+                    const valueOL = this.visit(valueArg);
+                    const inExpr = [
+                        "in",
+                        valueOL,
+                        ["literal", arrayOL],
+                    ];
+                    // indexof(...) != -1 → is in
+                    if (operator === "!=") {
+                        return inExpr;
+                    }
+                    // indexof(...) == -1 → is NOT in
+                    if (operator === "==") {
+                        return ["!", inExpr];
+                    }
+                }
+            }
+        }
         const leftOL = this.visit(left);
         const rightOL = this.visit(right);
         const olOp = OPERATOR_MAPPING[operator];
@@ -177,6 +206,10 @@ class VegaToOLVisitor {
         else {
             throw new Vega2OLError(`Unsupported function call`);
         }
+        if (this.isIndexOfCall(node)) {
+            throw new Vega2OLError(`indexof is only supported in the pattern 'indexof(array, value) != -1' (or '== -1'), ` +
+                `it cannot be used as a standalone expression in OpenLayers`);
+        }
         const olFunc = FUNCTION_MAPPING[funcName.toLowerCase()];
         if (!olFunc) {
             throw new Vega2OLError(`Unsupported function: ${funcName}`);

package/dist/tests/test-basic.js

@@ -14,6 +14,30 @@ function assertEqual(actual, expected, message) {
         return false;
     }
 }
+// Assert that vega2ol throws a Vega2OLError for the given expression
+async function assertThrows(expr, message, messageContains) {
+    try {
+        const result = await vega2ol(expr);
+        console.log(`   ❌ ${message}`);
+        console.log(`   Expected a Vega2OLError, but got result: ${JSON.stringify(result)}`);
+        return false;
+    }
+    catch (error) {
+        if (!(error instanceof Vega2OLError)) {
+            console.log(`   ❌ ${message}`);
+            console.log(`   Expected Vega2OLError, got: ${error.constructor.name}: ${error.message}`);
+            return false;
+        }
+        if (messageContains && !error.message.includes(messageContains)) {
+            console.log(`   ❌ ${message}`);
+            console.log(`   Error message did not contain "${messageContains}"`);
+            console.log(`   Got message: ${error.message}`);
+            return false;
+        }
+        console.log(`   ✅ ${message}`);
+        return true;
+    }
+}
 // Run tests
 async function runTests() {
     console.log("🚀 Testing vega2ol transpiler\n");
@@ -106,7 +130,43 @@ async function runTests() {
             passed++;
         else
             failed++;
-        if (assertEqual(await vega2ol("pow(datum.base, 2)"), ["pow", ["get", "base"], 2], "Pow function with multiple args"))
+        if (assertEqual(await vega2ol("ceil(datum.value)"), ["ceil", ["get", "value"]], "ceil()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("round(datum.value)"), ["round", ["get", "value"]], "round()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("abs(datum.value)"), ["abs", ["get", "value"]], "abs()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("sqrt(datum.value)"), ["sqrt", ["get", "value"]], "sqrt()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("sin(datum.value)"), ["sin", ["get", "value"]], "sin()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("cos(datum.value)"), ["cos", ["get", "value"]], "cos()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("pow(datum.base, 2)"), ["^", ["get", "base"], 2], "pow() maps to OL's '^' operator, not a 'pow' function"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("atan(datum.value)"), ["atan", ["get", "value"]], "atan() single-arg form"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("atan2(datum.x, datum.y)"), ["atan", ["get", "x"], ["get", "y"]], "atan2() two-arg form"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("clamp(datum.value, 0, 100)"), ["clamp", ["get", "value"], 0, 100], "clamp() preserves (value, min, max) arg order"))
             passed++;
         else
             failed++;
@@ -133,7 +193,85 @@ async function runTests() {
             passed++;
         else
             failed++;
-        // Test 13: Error handling
+        // Test 13: Binary expressions
+        console.log("\n📋 Binary Expressions");
+        if (assertEqual(await vega2ol("indexof(['USA', 'India'], datum.country) != -1"), ["in", ["get", "country"], ["literal", ["USA", "India"]]], "indexOf with != -1 (is in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-1 != indexof(['USA', 'India'], datum.country)"), ["in", ["get", "country"], ["literal", ["USA", "India"]]], "reverse indexOf with != -1 (is in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("indexof(['hot', 'warm'], datum.temperature) != -1 ? 'red' : 'blue'"), [
+            "case",
+            ["in", ["get", "temperature"], ["literal", ["hot", "warm"]]],
+            "red",
+            "blue",
+        ], "indexOf in ternary (if in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("indexof(['USA', 'India'], datum.country) == -1"), ["!", ["in", ["get", "country"], ["literal", ["USA", "India"]]]], "indexOf with == -1 (is not in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-1 == indexof(['USA', 'India'], datum.country)"), ["!", ["in", ["get", "country"], ["literal", ["USA", "India"]]]], "reverse indexOf with == -1 (is not in)"))
+            passed++;
+        else
+            failed++;
+        // Test 14: Unsupported / unknown function errors
+        console.log("\n📋 Errors: Vega Functions With No OL Equivalent");
+        if (await assertThrows("upper(datum.name)", "upper() throws (no OL string case operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("lower(datum.name)", "lower() throws (no OL string case operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("toString(datum.value)", "toString() throws (no OL type coercion operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("isValid(datum.value)", "isValid() throws (no OL type-checking operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("length(datum.items)", "length() throws (no OL length operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("format(datum.value, ',.2f')", "format() throws (no OL number-formatting operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("now()", "now() throws (no OL date/time operators)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("min(datum.a, datum.b)", "min() throws (no OL aggregate min/max operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("tan(datum.value)", "tan() throws (OL only supports sin/cos/atan)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("indexof(datum.items, 'x')", "bare indexof() outside the != -1 / == -1 pattern throws a specific error", "indexof is only supported in the pattern"))
+            passed++;
+        else
+            failed++;
+        console.log("\n📋 Errors: Names That Don't Exist In Vega Or OL");
+        if (await assertThrows("totallyMadeUpFunction(datum.value)", "Nonexistent function name throws", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("fooBarBaz(1, 2, 3)", "Another nonexistent function name throws", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        // Test 15: Error handling
         console.log("\n📋 Error Handling");
         try {
             await vega2ol(null);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vega2ol",
-    "version": "1.1.1",
+    "version": "1.1.3",
     "description": "Vega expression to Open-Layers expression transpiler",
     "keywords": [
         "vega",
@@ -31,7 +31,8 @@
     "scripts": {
         "build": "tsc",
         "test": "node dist/tests/test-basic.js",
-        "dev": "tsc --watch"
+        "dev": "tsc --watch",
+        "clean": "rm -rf dist"
     },
     "dependencies": {
         "vega-expression": "^6.1.0"