vega2ol 1.1.3 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vega2ol",
-    "version": "1.1.3",
+    "version": "1.1.4",
     "description": "Vega expression to Open-Layers expression transpiler",
     "keywords": [
         "vega",

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/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): ExpressionValue;
-export { ExpressionValue as OLExpression, VegaNode };

package/dist/main.js

@@ -1,273 +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
-    "+": "+",
-    "-": "-",
-    "*": "*",
-    "/": "/",
-    "%": "%",
-};
-/**
- * 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: "^",
-    sin: "sin",
-    cos: "cos",
-    atan: "atan",
-    atan2: "atan",
-    clamp: "clamp",
-};
-/**
- * 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 = {};
-    }
-    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");
-        }
-        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`);
-    }
-    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];
-        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`);
-        }
-        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}`);
-        }
-        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 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}`);
-    }
-}

package/dist/tests/test-basic.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/test-basic.js

@@ -1,303 +0,0 @@
-import { vega2ol, Vega2OLError } from "../main.js";
-// Simple assertion helper
-function assertEqual(actual, expected, message) {
-    const actualStr = JSON.stringify(actual);
-    const expectedStr = JSON.stringify(expected);
-    if (actualStr === expectedStr) {
-        console.log(`   ✅ ${message}`);
-        return true;
-    }
-    else {
-        console.log(`   ❌ ${message}`);
-        console.log(`   Expected: ${expectedStr}`);
-        console.log(`   Got:      ${actualStr}`);
-        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");
-    let passed = 0;
-    let failed = 0;
-    try {
-        // Test 1: Literal values
-        console.log("📋 Literal Values");
-        if (assertEqual(await vega2ol("42"), 42, "Number literal"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("'hello'"), "hello", "String literal"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("true"), true, "Boolean literal"))
-            passed++;
-        else
-            failed++;
-        // Test 2: Member access
-        console.log("\n📋 Member Access (datum.field)");
-        if (assertEqual(await vega2ol("datum.value"), ["get", "value"], "Simple datum access"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("datum.population"), ["get", "population"], "Datum field access"))
-            passed++;
-        else
-            failed++;
-        // Test 3: Comparison operators
-        console.log("\n📋 Comparison Operators");
-        if (assertEqual(await vega2ol("datum.value > 100"), [">", ["get", "value"], 100], "Greater than operator"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("datum.value == 100"), ["==", ["get", "value"], 100], "Equality operator"))
-            passed++;
-        else
-            failed++;
-        // Test 4: Ternary/Conditional (the main example from docs)
-        console.log("\n📋 Conditional Expressions");
-        if (assertEqual(await vega2ol("datum.value > 100 ? 'red' : 'blue'"), ["case", [">", ["get", "value"], 100], "red", "blue"], "Simple ternary expression"))
-            passed++;
-        else
-            failed++;
-        // Test 5: Complex nested conditional
-        if (assertEqual(await vega2ol("datum.value > 100 ? 'red' : datum.value > 50 ? 'yellow' : 'green'"), [
-            "case",
-            [">", ["get", "value"], 100],
-            "red",
-            ["case", [">", ["get", "value"], 50], "yellow", "green"],
-        ], "Nested ternary expression"))
-            passed++;
-        else
-            failed++;
-        // Test 6: Logical operators
-        console.log("\n📋 Logical Operators");
-        if (assertEqual(await vega2ol("datum.x > 0 && datum.y < 100"), ["all", [">", ["get", "x"], 0], ["<", ["get", "y"], 100]], "AND operator"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("datum.a > 1 || datum.b < 5"), ["any", [">", ["get", "a"], 1], ["<", ["get", "b"], 5]], "OR operator"))
-            passed++;
-        else
-            failed++;
-        // Test 7: Arithmetic operators
-        console.log("\n📋 Arithmetic Operators");
-        if (assertEqual(await vega2ol("datum.a + datum.b"), ["+", ["get", "a"], ["get", "b"]], "Addition operator"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("datum.a * datum.b"), ["*", ["get", "a"], ["get", "b"]], "Multiplication operator"))
-            passed++;
-        else
-            failed++;
-        // Test 8: Unary operations
-        console.log("\n📋 Unary Operations");
-        if (assertEqual(await vega2ol("!datum.active"), ["!", ["get", "active"]], "Negation operator"))
-            passed++;
-        else
-            failed++;
-        if (assertEqual(await vega2ol("-datum.value"), ["*", ["get", "value"], -1], "Unary minus"))
-            passed++;
-        else
-            failed++;
-        // Test 9: Function calls
-        console.log("\n📋 Function Calls");
-        if (assertEqual(await vega2ol("floor(datum.value)"), ["floor", ["get", "value"]], "Floor function"))
-            passed++;
-        else
-            failed++;
-        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++;
-        // Test 10: Real-world example - Color mapping
-        console.log("\n📋 Real-world Examples");
-        if (assertEqual(await vega2ol("datum.population > 1000000 ? '#FF0000' : datum.population > 500000 ? '#FFA500' : '#FFFF00'"), [
-            "case",
-            [">", ["get", "population"], 1000000],
-            "#FF0000",
-            ["case", [">", ["get", "population"], 500000], "#FFA500", "#FFFF00"],
-        ], "Color mapping by population size"))
-            passed++;
-        else
-            failed++;
-        // Test 11: Array expressions
-        console.log("\n📋 Array Expressions");
-        if (assertEqual(await vega2ol("[1, 2, 3]"), [1, 2, 3], "Array literal"))
-            passed++;
-        else
-            failed++;
-        // Test 12: Constants
-        console.log("\n📋 Vega Constants");
-        if (assertEqual(await vega2ol("PI"), Math.PI, "PI constant"))
-            passed++;
-        else
-            failed++;
-        // 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);
-            console.log("❌ Should throw for null input");
-            failed++;
-        }
-        catch (error) {
-            if (error instanceof Vega2OLError) {
-                console.log("   ✅ Throws Vega2OLError for invalid input");
-                passed++;
-            }
-            else {
-                console.log("❌ Wrong error type");
-                failed++;
-            }
-        }
-    }
-    catch (error) {
-        console.error("🔥 Test suite error:", error);
-        failed++;
-    }
-    // Summary
-    console.log("\n" + "=".repeat(50));
-    console.log(`📊 Test Results: ${passed} passed, ${failed} failed`);
-    console.log("=".repeat(50));
-    return failed === 0 ? 0 : 1;
-}
-// Run the tests
-runTests().then((code) => process.exit(code));