vega2ol 1.0.0

package/README.md

@@ -0,0 +1,154 @@
+# vega2ol
+
+A TypeScript library to transpile [Vega expressions](https://vega.github.io/vega/docs/expressions/) to [OpenLayers](https://openlayers.org/) expressions.
+
+## Overview
+
+`vega2ol` automatically converts Vega expression syntax to OpenLayers array-based expression format. This enables seamless integration between Vega-Lite/Vega visualization specifications and OpenLayers map styling.
+
+### Example
+
+**Vega Expression:**
+```javascript
+datum.value > 100 ? 'red' : 'blue'
+```
+
+**OpenLayers Expression:**
+```javascript
+['case', ['>', ['get', 'value'], 100], 'red', 'blue']
+```
+
+## Installation
+
+```bash
+npm install vega2ol
+```
+
+## Quick Start
+
+```typescript
+import { vega2ol } from 'vega2ol';
+
+// Simple conditional styling
+const olExpr = vega2ol("datum.population > 1000000 ? '#FF0000' : '#0000FF'");
+// Returns: ['case', ['>', ['get', 'population'], 1000000], '#FF0000', '#0000FF']
+
+// Use in OpenLayers style
+const style = {
+  'fill-color': olExpr
+};
+```
+
+## Supported Features
+
+### Literals
+- Numbers: `42`, `3.14`, `-10`
+- Strings: `'hello'`, `"world"`
+- Booleans: `true`, `false`
+- Null: `null`
+
+### Member Access
+- `datum.fieldName` → `['get', 'fieldName']`
+- Works with any data field
+
+### Operators
+
+**Comparison:**
+- `==`, `!=`, `<`, `<=`, `>`, `>=`
+
+**Logical:**
+- `&&` (AND) → maps to `all`
+- `||` (OR) → maps to `any`
+- `!` (NOT) → maps to `!`
+
+**Arithmetic:**
+- `+`, `-`, `*`, `/`, `%`
+
+### Conditional Expressions
+- Ternary operator: `condition ? true_value : false_value`
+- Nested ternaries supported for multiple conditions
+
+### Functions
+
+**Math Functions:**
+- `floor()`, `ceil()`, `round()`, `abs()`, `sqrt()`
+- `pow()`, `log()`, `exp()`, `sin()`, `cos()`, `tan()`
+- `min()`, `max()`
+
+**String Functions:**
+- `tostring()`, `upper()`, `lower()`, `substring()`
+
+**Array Functions:**
+- `length()`, `indexof()`, `slice()`
+
+**Type Functions:**
+- `type()`, `isvalid()`, `isnumber()`, `isstring()`, `isboolean()`
+
+### Vega Constants
+- Math: `PI`, `E`, `LN2`, `LN10`, `LOG2E`, `LOG10E`, `SQRT1_2`, `SQRT2`
+- Number: `MIN_VALUE`, `MAX_VALUE`
+
+## Development
+
+### Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+```
+
+### Testing
+
+```bash
+# Run tests
+npm test
+```
+
+### Architecture
+
+The transpiler uses a **visitor pattern** similar to AST walkers:
+
+1. **Parser**: Uses `vega-expression` to parse Vega expressions into an Abstract Syntax Tree (AST)
+2. **Visitor**: `VegaToOLVisitor` class walks the AST and converts each node type to OpenLayers format
+3. **Output**: Returns OpenLayers expression array
+
+## Examples
+
+### Color Mapping Based on Value
+
+```typescript
+const vegaExpr = `
+  datum.value > 100 ? 'red' :
+  datum.value > 50 ? 'yellow' :
+  'green'
+`;
+const olExpr = vega2ol(vegaExpr);
+// Use with OpenLayers style
+style['fill-color'] = olExpr;
+```
+
+### Opacity Based on Category
+
+```typescript
+const vegaExpr = "datum.category == 'important' ? 1 : 0.5";
+const olExpr = vega2ol(vegaExpr);
+style['fill-opacity'] = olExpr;
+```
+
+### Complex Conditions
+
+```typescript
+const vegaExpr = `
+  (datum.x > 0 && datum.y < 100) ? 'inside' : 'outside'
+`;
+const olExpr = vega2ol(vegaExpr);
+```
+
+## Resources
+
+- [Vega Expression Documentation](https://vega.github.io/vega/docs/expressions/)
+- [Vega Expression Parser](https://github.com/vega/vega/tree/main/packages/vega-expression)
+- [OpenLayers Documentation](https://openlayers.org/)

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/main.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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)
+ */
+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<OLExpression>;
+export { OLExpression, VegaNode };

package/dist/main.js

@@ -0,0 +1,238 @@
+/**
+ * Operator mapping from Vega operators to OpenLayers operators
+ */
+const OPERATOR_MAPPING = {
+    // Comparison operators
+    "==": "==",
+    "!=": "!=",
+    "<": "<",
+    "<=": "<=",
+    ">": ">",
+    ">=": ">=",
+    // Logical operators
+    "&&": "all",
+    "||": "any",
+    // Arithmetic operators
+    "+": "+",
+    "-": "-",
+    "*": "*",
+    "/": "/",
+    "%": "%",
+    // Other
+    "**": "pow",
+};
+/**
+ * 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);
+        // 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}`);
+        }
+        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));
+    }
+    // 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];
+        }
+        // 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];
+        }
+        // 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 {
+        // 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
+        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/src/index.d.ts

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

package/dist/src/index.js

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

package/dist/src/main.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,240 @@
+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}`);
+    }
+}

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

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

package/dist/tests/test-basic.js

@@ -0,0 +1,165 @@
+import { vega2ol, Vega2OLError } from "../src/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;
+    }
+}
+// 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("pow(datum.base, 2)"), ["pow", ["get", "base"], 2], "Pow function with multiple args"))
+            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: 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));

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "vega2ol",
+    "version": "1.0.0",
+    "description": "Vega expression to Open-Layers expression transpiler",
+    "keywords": [
+        "vega",
+        "openlayers",
+        "expression",
+        "transpiler",
+        "geospatial"
+    ],
+    "homepage": "https://github.com/nakul-py/vega2ol#readme",
+    "bugs": {
+        "url": "https://github.com/nakul-py/vega2ol/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nakul-py/vega2ol.git"
+    },
+    "license": "BSD-3-Clause",
+    "author": "nakul",
+    "type": "module",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "directories": {
+        "test": "tests"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "test": "node dist/tests/test-basic.js",
+        "dev": "tsc --watch"
+    },
+    "dependencies": {
+        "vega-expression": "^6.1.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.19.39",
+        "ol": "^9.2.4",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.9.3"
+    }
+}