vega2ol 1.1.0 → 1.1.2

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Vega2ol Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 /**
  * vega2ol - Vega expression to OpenLayers expression transpiler
  */
-export { vega2ol, Vega2OLError, OLExpression, VegaNode } from './main.js';
+export { vega2ol, Vega2OLError, VegaNode } from './main.js';

package/dist/main.d.ts

@@ -1,8 +1,8 @@
+import type { ExpressionValue } from "ol/expr/expression.js";
 /**
  * OpenLayers expression types
  * OL expressions are arrays: ['operator', arg1, arg2, ...] or ['case', condition, value, ...]
  */
-type OLExpression = any[] | string | number | boolean | null;
 /**
  * Vega AST node types (simplified)
  */
@@ -21,5 +21,5 @@ export declare class Vega2OLError extends Error {
  * @param vegaExpressionStr - A Vega expression string (e.g., "datum.value > 100 ? 'red' : 'blue'")
  * @returns OpenLayers expression array
  */
-export declare function vega2ol(vegaExpressionStr: string): Promise<OLExpression>;
-export { OLExpression, VegaNode };
+export declare function vega2ol(vegaExpressionStr: string): ExpressionValue;
+export { ExpressionValue as OLExpression, VegaNode };

package/dist/main.js

@@ -1,3 +1,4 @@
+import { parseExpression } from "vega-expression";
 /**
  * Operator mapping from Vega operators to OpenLayers operators
  */
@@ -18,8 +19,21 @@ const OPERATOR_MAPPING = {
     "*": "*",
     "/": "/",
     "%": "%",
-    // Other
-    "**": "pow",
+};
+/**
+ * Constants mapping from Vega constants to OpenLayers constants
+ */
+const CONSTANTS_MAPPING = {
+    PI: Math.PI,
+    E: Math.E,
+    LN2: Math.LN2,
+    LN10: Math.LN10,
+    LOG2E: Math.LOG2E,
+    LOG10E: Math.LOG10E,
+    SQRT1_2: Math.SQRT1_2,
+    SQRT2: Math.SQRT2,
+    MIN_VALUE: Number.MIN_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
 };
 /**
  * Function mapping from Vega functions to OpenLayers functions
@@ -31,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
@@ -73,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");
@@ -112,21 +122,42 @@ 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, 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);
-        // Handle special cases
-        if (operator === "in") {
-            return ["in", leftOL, rightOL];
-        }
-        if (operator === "&&") {
-            return ["all", leftOL, rightOL];
-        }
-        if (operator === "||") {
-            return ["any", leftOL, rightOL];
-        }
         const olOp = OPERATOR_MAPPING[operator];
         if (!olOp) {
             throw new Vega2OLError(`Unsupported binary operator: ${operator}`);
@@ -171,6 +202,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}`);
@@ -183,6 +218,17 @@ class VegaToOLVisitor {
         const { elements } = node;
         return elements.map((elem) => this.visit(elem));
     }
+    // Logical expressions
+    visitLogicalExpression(node) {
+        const { operator, left, right } = node;
+        const leftOL = this.visit(left);
+        const rightOL = this.visit(right);
+        const olOp = OPERATOR_MAPPING[operator];
+        if (!olOp) {
+            throw new Vega2OLError(`Unsupported logical operator: ${operator}`);
+        }
+        return [olOp, leftOL, rightOL];
+    }
     // Identifier/Variable: x, PI, etc.
     visitIdentifier(node) {
         const { name } = node;
@@ -190,21 +236,8 @@ class VegaToOLVisitor {
         if (name in this.scope) {
             return this.scope[name];
         }
-        // Vega constants
-        const vegaConstants = {
-            PI: Math.PI,
-            E: Math.E,
-            LN2: Math.LN2,
-            LN10: Math.LN10,
-            LOG2E: Math.LOG2E,
-            LOG10E: Math.LOG10E,
-            SQRT1_2: Math.SQRT1_2,
-            SQRT2: Math.SQRT2,
-            MIN_VALUE: Number.MIN_VALUE,
-            MAX_VALUE: Number.MAX_VALUE,
-        };
-        if (name in vegaConstants) {
-            return vegaConstants[name];
+        if (name in CONSTANTS_MAPPING) {
+            return CONSTANTS_MAPPING[name];
         }
         // Return as string (might be a function or field)
         return name;
@@ -215,13 +248,11 @@ class VegaToOLVisitor {
  * @param vegaExpressionStr - A Vega expression string (e.g., "datum.value > 100 ? 'red' : 'blue'")
  * @returns OpenLayers expression array
  */
-export async function vega2ol(vegaExpressionStr) {
+export function vega2ol(vegaExpressionStr) {
     if (typeof vegaExpressionStr !== "string") {
         throw new Vega2OLError("Input must be a string");
     }
     try {
-        // Dynamically import parseExpression to handle ESM
-        const { parseExpression } = await import("vega-expression");
         // Parse Vega expression to AST
         const ast = parseExpression(vegaExpressionStr);
         // Visit the AST and convert to OL expression

package/dist/tests/test-basic.js

@@ -1,4 +1,4 @@
-import { vega2ol, Vega2OLError } from "../src/main.js";
+import { vega2ol, Vega2OLError } from "../main.js";
 // Simple assertion helper
 function assertEqual(actual, expected, message) {
     const actualStr = JSON.stringify(actual);
@@ -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"], ["USA", "India"]], "indexOf with != -1 (is in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-1 != indexof(['USA', 'India'], datum.country)"), ["in", ["get", "country"], ["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"], ["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"], ["USA", "India"]]], "indexOf with == -1 (is not in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-1 == indexof(['USA', 'India'], datum.country)"), ["!", ["in", ["get", "country"], ["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.0",
+    "version": "1.1.2",
     "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"

package/dist/src/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * vega2ol - Vega expression to OpenLayers expression transpiler
- */
-export { vega2ol, Vega2OLError, VegaNode } from './main.js';

package/dist/src/index.js

@@ -1,4 +0,0 @@
-/**
- * vega2ol - Vega expression to OpenLayers expression transpiler
- */
-export { vega2ol, Vega2OLError } from './main.js';

package/dist/src/main.d.ts

@@ -1,25 +0,0 @@
-import type { ExpressionValue } from "ol/expr/expression.js";
-/**
- * OpenLayers expression types
- * OL expressions are arrays: ['operator', arg1, arg2, ...] or ['case', condition, value, ...]
- */
-/**
- * Vega AST node types (simplified)
- */
-interface VegaNode {
-    type: string;
-    [key: string]: any;
-}
-/**
- * Custom error class for Vega2OL transpilation errors
- */
-export declare class Vega2OLError extends Error {
-    constructor(message: string);
-}
-/**
- * Main transpiler function
- * @param vegaExpressionStr - A Vega expression string (e.g., "datum.value > 100 ? 'red' : 'blue'")
- * @returns OpenLayers expression array
- */
-export declare function vega2ol(vegaExpressionStr: string): Promise<ExpressionValue>;
-export { ExpressionValue as OLExpression, VegaNode };

package/dist/src/main.js

@@ -1,240 +0,0 @@
-import { parseExpression } from "vega-expression";
-/**
- * Operator mapping from Vega operators to OpenLayers operators
- */
-const OPERATOR_MAPPING = {
-    // Comparison operators
-    "==": "==",
-    "!=": "!=",
-    "<": "<",
-    "<=": "<=",
-    ">": ">",
-    ">=": ">=",
-    // Logical operators
-    "&&": "all",
-    "||": "any",
-    // Arithmetic operators
-    "+": "+",
-    "-": "-",
-    "*": "*",
-    "/": "/",
-    "%": "%",
-    // Other
-    "**": "pow",
-};
-/**
-* Constants mapping from Vega constants to OpenLayers constants
-*/
-const CONSTANTS_MAPPING = {
-    PI: Math.PI,
-    E: Math.E,
-    LN2: Math.LN2,
-    LN10: Math.LN10,
-    LOG2E: Math.LOG2E,
-    LOG10E: Math.LOG10E,
-    SQRT1_2: Math.SQRT1_2,
-    SQRT2: Math.SQRT2,
-    MIN_VALUE: Number.MIN_VALUE,
-    MAX_VALUE: Number.MAX_VALUE,
-};
-/**
- * Function mapping from Vega functions to OpenLayers functions
- */
-const FUNCTION_MAPPING = {
-    // Math functions
-    abs: "abs",
-    floor: "floor",
-    ceil: "ceil",
-    round: "round",
-    sqrt: "sqrt",
-    pow: "pow",
-    log: "log",
-    exp: "exp",
-    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",
-};
-/**
- * Custom error class for Vega2OL transpilation errors
- */
-export class Vega2OLError extends Error {
-    constructor(message) {
-        const fullMessage = `${message}, note that only a subset of Vega is supported`;
-        super(fullMessage);
-        this.name = "Vega2OLError";
-    }
-}
-/**
- * Visitor class to convert Vega AST to OpenLayers expressions
- */
-class VegaToOLVisitor {
-    constructor() {
-        this.scope = {};
-    }
-    visit(node) {
-        if (!node || !node.type) {
-            throw new Vega2OLError("Invalid AST node");
-        }
-        const method = `visit${node.type}`;
-        if (typeof this[method] === "function") {
-            return this[method](node);
-        }
-        throw new Vega2OLError(`Unsupported ${node.type} node`);
-    }
-    // Literal values
-    visitLiteral(node) {
-        const { value } = node;
-        if (value === null)
-            return null;
-        if (typeof value === "boolean")
-            return value;
-        if (typeof value === "number")
-            return value;
-        if (typeof value === "string")
-            return value;
-        throw new Vega2OLError(`Unsupported literal type: ${typeof value}`);
-    }
-    // Member access: datum.value, datum['value']
-    visitMemberExpression(node) {
-        const { object, property } = node;
-        if (object.type === "Identifier" && object.name === "datum") {
-            if (typeof property === "string") {
-                return ["get", property];
-            }
-            // For computed properties - if property is an Identifier with 'name'
-            if (property.type === "Identifier" && property.name) {
-                return ["get", property.name];
-            }
-            // For computed properties like datum[variable]
-            return ["get", this.visit(property)];
-        }
-        throw new Vega2OLError(`Unsupported member access`);
-    }
-    // Binary operations: a + b, a > b, etc.
-    visitBinaryExpression(node) {
-        const { operator, left, right } = node;
-        const leftOL = this.visit(left);
-        const rightOL = this.visit(right);
-        const olOp = OPERATOR_MAPPING[operator];
-        if (!olOp) {
-            throw new Vega2OLError(`Unsupported binary operator: ${operator}`);
-        }
-        return [olOp, leftOL, rightOL];
-    }
-    // Unary operations: !x, -x, +x
-    visitUnaryExpression(node) {
-        const { operator, argument } = node;
-        const argOL = this.visit(argument);
-        if (operator === "!") {
-            return ["!", argOL];
-        }
-        if (operator === "-") {
-            return ["*", argOL, -1];
-        }
-        if (operator === "+") {
-            return argOL;
-        }
-        throw new Vega2OLError(`Unsupported unary operator: ${operator}`);
-    }
-    // Conditional: test ? consequent : alternate
-    visitConditionalExpression(node) {
-        const { test, consequent, alternate } = node;
-        const testOL = this.visit(test);
-        const consequentOL = this.visit(consequent);
-        const alternateOL = this.visit(alternate);
-        // OL 'case' expression: ['case', condition1, value1, condition2, value2, ..., defaultValue]
-        return ["case", testOL, consequentOL, alternateOL];
-    }
-    // Function calls: floor(x), ceil(y), etc.
-    visitCallExpression(node) {
-        const { callee, arguments: args } = node;
-        let funcName;
-        if (callee.type === "Identifier") {
-            funcName = callee.name;
-        }
-        else if (callee.type === "MemberExpression" &&
-            callee.object.name === "Math") {
-            funcName = callee.property;
-        }
-        else {
-            throw new Vega2OLError(`Unsupported function call`);
-        }
-        const olFunc = FUNCTION_MAPPING[funcName.toLowerCase()];
-        if (!olFunc) {
-            throw new Vega2OLError(`Unsupported function: ${funcName}`);
-        }
-        const olArgs = args.map((arg) => this.visit(arg));
-        return [olFunc, ...olArgs];
-    }
-    // Array literal: [1, 2, 3]
-    visitArrayExpression(node) {
-        const { elements } = node;
-        return elements.map((elem) => this.visit(elem));
-    }
-    // Logical expressions
-    visitLogicalExpression(node) {
-        const { operator, left, right } = node;
-        const leftOL = this.visit(left);
-        const rightOL = this.visit(right);
-        const olOp = OPERATOR_MAPPING[operator];
-        if (!olOp) {
-            throw new Vega2OLError(`Unsupported logical operator: ${operator}`);
-        }
-        return [olOp, leftOL, rightOL];
-    }
-    // Identifier/Variable: x, PI, etc.
-    visitIdentifier(node) {
-        const { name } = node;
-        // Check if it's in the current scope
-        if (name in this.scope) {
-            return this.scope[name];
-        }
-        if (name in CONSTANTS_MAPPING) {
-            return CONSTANTS_MAPPING[name];
-        }
-        // Return as string (might be a function or field)
-        return name;
-    }
-}
-/**
- * Main transpiler function
- * @param vegaExpressionStr - A Vega expression string (e.g., "datum.value > 100 ? 'red' : 'blue'")
- * @returns OpenLayers expression array
- */
-export async function vega2ol(vegaExpressionStr) {
-    if (typeof vegaExpressionStr !== "string") {
-        throw new Vega2OLError("Input must be a string");
-    }
-    try {
-        // Parse Vega expression to AST
-        const ast = parseExpression(vegaExpressionStr);
-        // Visit the AST and convert to OL expression
-        const visitor = new VegaToOLVisitor();
-        const olExpression = visitor.visit(ast);
-        return olExpression;
-    }
-    catch (error) {
-        if (error instanceof Vega2OLError) {
-            throw error;
-        }
-        throw new Vega2OLError(`Failed to parse expression: ${error.message}`);
-    }
-}