vega2ol 1.0.0 → 1.1.1

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
  */
@@ -21,6 +22,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
  */
@@ -117,16 +133,6 @@ class VegaToOLVisitor {
         const { operator, left, right } = node;
         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}`);
@@ -183,6 +189,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 +207,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 +219,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);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vega2ol",
-    "version": "1.0.0",
+    "version": "1.1.1",
     "description": "Vega expression to Open-Layers expression transpiler",
     "keywords": [
         "vega",
@@ -9,13 +9,13 @@
         "transpiler",
         "geospatial"
     ],
-    "homepage": "https://github.com/nakul-py/vega2ol#readme",
+    "homepage": "https://github.com/geojupyter/vega2ol#readme",
     "bugs": {
-        "url": "https://github.com/nakul-py/vega2ol/issues"
+        "url": "https://github.com/geojupyter/vega2ol/issues"
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/nakul-py/vega2ol.git"
+        "url": "git+https://github.com/geojupyter/vega2ol.git"
     },
     "license": "BSD-3-Clause",
     "author": "nakul",

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}`);
-    }
-}