Remove async

Author: cmdcolin

CHANGELOG.md

@@ -6,6 +6,28 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 Nothing yet!
 
+## [v3.0.0]
+
+### BREAKING CHANGES
+
+- **Removed async evaluation support**: Jexl now only supports synchronous evaluation
+- **Renamed methods**: `evalSync()` has been renamed to `eval()`. The async `eval()` method has been removed.
+- **Removed PromiseSync class**: Internal implementation detail removed
+- **Synchronous transforms/functions only**: Custom transforms and functions must now be synchronous. They should return values directly rather than Promises.
+
+### Changed
+
+- Simplified codebase by removing Promise/PromiseSync abstraction layer
+- All evaluation is now synchronous, improving performance and simplifying error handling
+- Errors are now thrown directly rather than being rejected Promises
+
+### Migration Guide
+
+- Replace `await jexl.eval(expr)` with `jexl.eval(expr)` (remove await)
+- Replace `jexl.evalSync(expr)` with `jexl.eval(expr)` (remove Sync suffix)
+- Update custom transforms/functions to be synchronous
+- Replace `.catch()` error handling with `try/catch` blocks
+
 ## [v2.3.0]
 
 ### Added

README.md

@@ -16,30 +16,30 @@ const context = {
 }
 
 // Template strings with interpolation
-jexl.evalSync('`Hello ${name.first} ${name.last}`', context)
+jexl.eval('`Hello ${name.first} ${name.last}`', context)
 // "Hello Sterling Archer"
 
-jexl.evalSync('`Age in 5 years: ${age + 5}`', context)
+jexl.eval('`Age in 5 years: ${age + 5}`', context)
 // "Age in 5 years: 41"
 
 // Filter arrays
-jexl.evalSync('assoc[.first == "Lana"].last', context)
+jexl.eval('assoc[.first == "Lana"].last', context)
 // "Kane"
 
 // Math operations
-jexl.evalSync('age * (3 - 1)', context)
+jexl.eval('age * (3 - 1)', context)
 // 72
 
 // String concatenation
-jexl.evalSync('name.first + " " + name.last', context)
+jexl.eval('name.first + " " + name.last', context)
 // "Sterling Archer"
 
 // Conditional logic
-jexl.evalSync('age > 62 ? "retired" : "working"', context)
+jexl.eval('age > 62 ? "retired" : "working"', context)
 // "working"
 
 // Array indexes
-jexl.evalSync('assoc[1].first', context)
+jexl.eval('assoc[1].first', context)
 // "Cyril"
 ```
 
@@ -63,17 +63,17 @@ Template strings use backticks and support expression interpolation with `${}`:
 ```javascript
 const context = { name: 'World', price: 10, qty: 3 }
 
-jexl.evalSync('`Hello ${name}!`', context)
+jexl.eval('`Hello ${name}!`', context)
 // "Hello World!"
 
-jexl.evalSync('`Total: $${price * qty}`', context)
+jexl.eval('`Total: $${price * qty}`', context)
 // "Total: $30"
 
 // Escape backticks and dollar signs with backslash
-jexl.evalSync('`Code: \\`example\\``')
+jexl.eval('`Code: \\`example\\``')
 // "Code: `example`"
 
-jexl.evalSync('`Price: \\$100`')
+jexl.eval('`Price: \\$100`')
 // "Price: $100"
 ```
 
@@ -103,10 +103,10 @@ const context = {
   lastEx: 2
 }
 
-jexl.evalSync('name.first', context) // "Malory"
-jexl.evalSync('name["last"]', context) // "Archer"
-jexl.evalSync('exes[2]', context) // "Burt"
-jexl.evalSync('exes[lastEx - 1]', context) // "Len"
+jexl.eval('name.first', context) // "Malory"
+jexl.eval('name["last"]', context) // "Archer"
+jexl.eval('exes[2]', context) // "Burt"
+jexl.eval('exes[lastEx - 1]', context) // "Len"
 ```
 
 ### Filtering Collections
@@ -123,13 +123,13 @@ const context = {
   ]
 }
 
-jexl.evalSync('employees[.first == "Sterling"]', context)
+jexl.eval('employees[.first == "Sterling"]', context)
 // [{ first: 'Sterling', last: 'Archer', age: 36 }]
 
-jexl.evalSync('employees[.age >= 30 && .age < 40]', context)
+jexl.eval('employees[.age >= 30 && .age < 40]', context)
 // [{ first: 'Sterling', ... }, { first: 'Lana', ... }]
 
-jexl.evalSync('employees[.last == "Kane"].first', context)
+jexl.eval('employees[.last == "Kane"].first', context)
 // "Lana"
 ```
 
@@ -141,10 +141,10 @@ Apply transforms to values using the pipe operator:
 jexl.addTransform('upper', (val) => val.toUpperCase())
 jexl.addTransform('split', (val, char) => val.split(char))
 
-jexl.evalSync('"hello"|upper')
+jexl.eval('"hello"|upper')
 // "HELLO"
 
-jexl.evalSync('"firstName lastName"|split(" ")[0]')
+jexl.eval('"firstName lastName"|split(" ")[0]')
 // "firstName"
 ```
 
@@ -156,10 +156,10 @@ Call functions in expressions:
 jexl.addFunction('min', Math.min)
 jexl.addFunction('max', Math.max)
 
-jexl.evalSync('min(5, 2, 9)')
+jexl.eval('min(5, 2, 9)')
 // 2
 
-jexl.evalSync('max(temperature, threshold)')
+jexl.eval('max(temperature, threshold)')
 // evaluates with context
 ```
 
@@ -168,10 +168,10 @@ jexl.evalSync('max(temperature, threshold)')
 Separate multiple expressions with semicolons. The result is the value of the last expression:
 
 ```javascript
-jexl.evalSync('5; 10; 15')
+jexl.eval('5; 10; 15')
 // 15
 
-jexl.evalSync('1 + 1; 2 + 2; 3 + 3')
+jexl.eval('1 + 1; 2 + 2; 3 + 3')
 // 6
 ```
 
@@ -180,17 +180,17 @@ jexl.evalSync('1 + 1; 2 + 2; 3 + 3')
 Assign values to variables using `=` (no `let`, `var`, or `const` needed). Assignments mutate the context and return the assigned value:
 
 ```javascript
-jexl.evalSync('x = 5')
+jexl.eval('x = 5')
 // 5
 
-jexl.evalSync('x = 5; x * 2')
+jexl.eval('x = 5; x * 2')
 // 10
 
-jexl.evalSync('x = 5; y = 10; x + y')
+jexl.eval('x = 5; y = 10; x + y')
 // 15
 
 const context = {}
-jexl.evalSync('x = 5; y = x * 2; y', context)
+jexl.eval('x = 5; y = x * 2; y', context)
 // 10
 // context is now { x: 5, y: 10 }
 ```
@@ -200,15 +200,12 @@ jexl.evalSync('x = 5; y = x * 2; y', context)
 ```javascript
 import jexl from '@jbrowse/jexl'
 
-// Synchronous evaluation
-const result = jexl.evalSync('expression', context)
-
-// Asynchronous evaluation (supports async transforms/functions)
-const result = await jexl.eval('expression', context)
+// Evaluate an expression
+const result = jexl.eval('expression', context)
 
 // Compile once, evaluate many times
 const expr = jexl.compile('name.first + " " + name.last')
-expr.evalSync({ name: { first: 'John', last: 'Doe' } })
+const result = expr.eval({ name: { first: 'John', last: 'Doe' } })
 ```
 
 ## License

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/jexl",
-  "version": "2.3.1",
+  "version": "3.0.0",
   "description": "A fork of the jexl lang for jbrowse",
   "type": "module",
   "types": "./dist/index.d.ts",

src/Expression.ts

@@ -4,7 +4,6 @@
  */
 
 import Lexer from './Lexer.ts'
-import PromiseSync from './PromiseSync.ts'
 import Evaluator from './evaluator/Evaluator.ts'
 import Parser from './parser/Parser.ts'
 
@@ -15,8 +14,6 @@ interface Grammar {
   [key: string]: any
 }
 
-type PromiseConstructor = typeof Promise | typeof PromiseSync
-
 class Expression {
   _grammar: Grammar
   _exprStr: string
@@ -44,44 +41,16 @@ class Expression {
   }
 
   /**
-   * Asynchronously evaluates the expression within an optional context.
-   * @param {Object} [context] A mapping of variables to values, which will be
-   *      made accessible to the Jexl expression when evaluating it
-   * @returns {Promise<*>} resolves with the result of the evaluation.
-   */
-  eval(context = {}) {
-    return this._eval(context, Promise)
-  }
-
-  /**
-   * Synchronously evaluates the expression within an optional context.
+   * Evaluates the expression within an optional context.
    * @param {Object} [context] A mapping of variables to values, which will be
    *      made accessible to the Jexl expression when evaluating it
    * @returns {*} the result of the evaluation.
    * @throws {*} on error
    */
-  evalSync(context = {}) {
-    const res = this._eval(context, PromiseSync as any) as PromiseSync
-    if (res.error) {
-      if (res.error instanceof Error) {
-        throw res.error
-      }
-      throw new Error(typeof res.error === 'string' ? res.error : JSON.stringify(res.error))
-    }
-    return res.value
-  }
-
-  _eval(context: any, promise: PromiseConstructor) {
-    return promise.resolve().then(() => {
-      const ast = this._getAst()
-      const evaluator = new Evaluator(
-        this._grammar,
-        context,
-        undefined,
-        promise
-      )
-      return evaluator.eval(ast!)
-    })
+  eval(context = {}) {
+    const ast = this._getAst()
+    const evaluator = new Evaluator(this._grammar, context)
+    return evaluator.eval(ast!)
   }
 
   _getAst() {

src/Jexl.ts

@@ -39,13 +39,11 @@ class Jexl {
    * @param {number} precedence The operator's precedence
    * @param {function} fn A function to run to calculate the result. The function
    *      will be called with two arguments: left and right, denoting the values
-   *      on either side of the operator. It should return either the resulting
-   *      value, or a Promise that resolves with the resulting value.
+   *      on either side of the operator. It should return the resulting value.
    * @param {boolean} [manualEval] If true, the `left` and `right` arguments
    *      will be wrapped in objects with an `eval` function. Calling
-   *      left.eval() or right.eval() will return a promise that resolves to
-   *      that operand's actual value. This is useful to conditionally evaluate
-   *      operands.
+   *      left.eval() or right.eval() will return that operand's actual value.
+   *      This is useful to conditionally evaluate operands.
    */
   addBinaryOp(
     operator: string,
@@ -88,8 +86,7 @@ class Jexl {
    * @param {string} operator The operator string to be added
    * @param {function} fn A function to run to calculate the result. The function
    *      will be called with one argument: the literal value to the right of the
-   *      operator. It should return either the resulting value, or a Promise
-   *      that resolves with the resulting value.
+   *      operator. It should return the resulting value.
    */
   addUnaryOp(operator: string, fn: (right: any) => any) {
     this._addGrammarElement(operator, {
@@ -163,28 +160,16 @@ class Jexl {
   }
 
   /**
-   * Asynchronously evaluates a Jexl string within an optional context.
-   * @param {string} expression The Jexl expression to be evaluated
-   * @param {Object} [context] A mapping of variables to values, which will be
-   *      made accessible to the Jexl expression when evaluating it
-   * @returns {Promise<*>} resolves with the result of the evaluation.
-   */
-  eval(expression: string, context = {}) {
-    const exprObj = this.createExpression(expression)
-    return exprObj.eval(context)
-  }
-
-  /**
-   * Synchronously evaluates a Jexl string within an optional context.
+   * Evaluates a Jexl string within an optional context.
    * @param {string} expression The Jexl expression to be evaluated
    * @param {Object} [context] A mapping of variables to values, which will be
    *      made accessible to the Jexl expression when evaluating it
    * @returns {*} the result of the evaluation.
    * @throws {*} on error
    */
-  evalSync(expression: string, context = {}) {
+  eval(expression: string, context = {}) {
     const exprObj = this.createExpression(expression)
-    return exprObj.evalSync(context)
+    return exprObj.eval(context)
   }
 
   /**