@jbrowse/jexl 2.3.1 → 3.0.1

package/src/evaluator/Evaluator.ts

@@ -12,9 +12,6 @@ interface Grammar {
   [key: string]: any
 }
 
-// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-type PromiseConstructor = typeof Promise | any
-
 /**
  * The Evaluator takes a Jexl expression tree as generated by the
  * {@link Parser} and calculates its value within a given context. The
@@ -26,127 +23,52 @@ type PromiseConstructor = typeof Promise | any
  * @param {{}} grammar A grammar object against which to evaluate the expression
  *      tree
  * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier. Any
- *      Promise values will be passed to the expression as their resolved
- *      value.
+ *      accessed to resolve the value of each non-relative identifier.
  * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
  *      to resolve the value of a relative identifier.
- * @param {function} promise A constructor for the Promise class to be used;
- *      probably either Promise or PromiseSync.
  */
 class Evaluator {
   _grammar: Grammar
   _context: any
   _relContext: any
-  Promise: PromiseConstructor
 
-  constructor(
-    grammar: Grammar,
-    context?: any,
-    relativeContext?: any,
-    promise: PromiseConstructor = Promise
-  ) {
+  constructor(grammar: Grammar, context?: any, relativeContext?: any) {
     this._grammar = grammar
     this._context = context || {}
     this._relContext = relativeContext || this._context
-    this.Promise = promise
   }
 
   /**
    * Evaluates an expression tree within the configured context.
    * @param {{}} ast An expression tree object
-   * @returns {Promise<*>} resolves with the resulting value of the expression.
+   * @returns {*} the resulting value of the expression.
    */
   eval(ast: AstNode) {
-    return this.Promise.resolve().then(() => {
-      return (handlers as any)[ast.type].call(this, ast)
-    })
+    return (handlers as any)[ast.type].call(this, ast)
   }
 
   /**
-   * Simultaneously evaluates each expression within an array, and delivers the
-   * response as an array with the resulting values at the same indexes as their
-   * originating expressions.
+   * Evaluates each expression within an array, and delivers the response as an
+   * array with the resulting values at the same indexes as their originating
+   * expressions.
    * @param {Array<string>} arr An array of expression strings to be evaluated
-   * @returns {Promise<Array<{}>>} resolves with the result array
+   * @returns {Array<{}>} the result array
    */
   evalArray(arr: AstNode[]) {
-    return this.Promise.all(arr.map((elem: AstNode) => this.eval(elem)))
+    return arr.map((elem: AstNode) => this.eval(elem))
   }
 
   /**
-   * Simultaneously evaluates each expression within a map, and delivers the
-   * response as a map with the same keys, but with the evaluated result for each
-   * as their value.
+   * Evaluates each expression within a map, and delivers the response as a map
+   * with the same keys, but with the evaluated result for each as their value.
    * @param {{}} map A map of expression names to expression trees to be
    *      evaluated
-   * @returns {Promise<{}>} resolves with the result map.
+   * @returns {{}} the result map.
    */
   evalMap(map: Record<string, AstNode>) {
     const entries = Object.entries(map)
-    const promises = entries.map(([_, ast]) => this.eval(ast))
-    return this.Promise.all(promises).then((vals: any[]) =>
-      Object.fromEntries(entries.map(([key], idx) => [key, vals[idx]]))
-    )
-  }
-
-  /**
-   * Applies a filter expression with relative identifier elements to a subject.
-   * The intent is for the subject to be an array of subjects that will be
-   * individually used as the relative context against the provided expression
-   * tree. Only the elements whose expressions result in a truthy value will be
-   * included in the resulting array.
-   *
-   * If the subject is not an array of values, it will be converted to a single-
-   * element array before running the filter.
-   * @param {*} subject The value to be filtered usually an array. If this value is
-   *      not an array, it will be converted to an array with this value as the
-   *      only element.
-   * @param {{}} expr The expression tree to run against each subject. If the
-   *      tree evaluates to a truthy result, then the value will be included in
-   *      the returned array otherwise, it will be eliminated.
-   * @returns {Promise<Array>} resolves with an array of values that passed the
-   *      expression filter.
-   * @private
-   */
-  _filterRelative(subject: any, expr: AstNode) {
-    const arr = Array.isArray(subject)
-      ? subject
-      : subject == null
-        ? []
-        : [subject]
-
-    const promises = arr.map((elem) =>
-      new Evaluator(this._grammar, this._context, elem, this.Promise).eval(expr)
-    )
-
-    return this.Promise.all(promises).then((values: any[]) =>
-      arr.filter((_, idx) => values[idx])
-    )
-  }
-
-  /**
-   * Applies a static filter expression to a subject value.  If the filter
-   * expression evaluates to boolean true, the subject is returned if false,
-   * undefined.
-   *
-   * For any other resulting value of the expression, this function will attempt
-   * to respond with the property at that name or index of the subject.
-   * @param {*} subject The value to be filtered.  Usually an Array (for which
-   *      the expression would generally resolve to a numeric index) or an
-   *      Object (for which the expression would generally resolve to a string
-   *      indicating a property name)
-   * @param {{}} expr The expression tree to run against the subject
-   * @returns {Promise<*>} resolves with the value of the drill-down.
-   * @private
-   */
-  _filterStatic(subject: any, expr: AstNode) {
-    return this.eval(expr).then((res: any) => {
-      if (typeof res === 'boolean') {
-        return res ? subject : undefined
-      }
-      return subject?.[res]
-    })
+    const vals = entries.map(([_, ast]) => this.eval(ast))
+    return Object.fromEntries(entries.map(([key], idx) => [key, vals[idx]]))
   }
 }
 

package/src/evaluator/handlers.ts

@@ -7,8 +7,7 @@ import type { AstNode } from '../types.ts'
 import type Evaluator from './Evaluator.ts'
 
 const poolNames: Record<string, string> = {
-  functions: 'Jexl Function',
-  transforms: 'Transform'
+  functions: 'Jexl Function'
 }
 
 /**
@@ -16,7 +15,7 @@ const poolNames: Record<string, string> = {
  * independently run through the evaluator.
  * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
  *      ObjectLiteral as the top node
- * @returns {Promise.<[]>} resolves to a map contained evaluated values.
+ * @returns {[]} an array of evaluated values.
  * @private
  */
 export function ArrayLiteral(this: Evaluator, ast: any) {
@@ -29,12 +28,12 @@ export function ArrayLiteral(this: Evaluator, ast: any) {
  * evaluators: `eval` is called with the left and right operands pre-evaluated.
  * `evalOnDemand`, if it exists, will be called with the left and right operands
  * each individually wrapped in an object with an "eval" function that returns
- * a promise with the resulting value. This allows the binary expression to
- * evaluate the operands conditionally.
+ * the resulting value. This allows the binary expression to evaluate the
+ * operands conditionally.
  * @param {{type: 'BinaryExpression', operator: <string>, left: {},
  *      right: {}}} ast An expression tree with a BinaryExpression as the top
  *      node
- * @returns {Promise<*>} resolves with the value of the BinaryExpression.
+ * @returns {*} the value of the BinaryExpression.
  * @private
  */
 export function BinaryExpression(this: Evaluator, ast: any) {
@@ -43,48 +42,45 @@ export function BinaryExpression(this: Evaluator, ast: any) {
     const wrap = (subAst: AstNode) => ({ eval: () => this.eval(subAst) })
     return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right))
   }
-  return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(
-    (arr: any[]) => grammarOp.eval(arr[0], arr[1])
-  )
+  const left = this.eval(ast.left)
+  const right = this.eval(ast.right)
+  return grammarOp.eval(left, right)
 }
 
 /**
  * Evaluates a ConditionalExpression node by first evaluating its test branch,
- * and resolving with the consequent branch if the test is truthy, or the
- * alternate branch if it is not. If there is no consequent branch, the test
- * result will be used instead.
+ * and returning the consequent branch if the test is truthy, or the alternate
+ * branch if it is not. If there is no consequent branch, the test result will
+ * be used instead.
  * @param {{type: 'ConditionalExpression', test: {}, consequent: {},
  *      alternate: {}}} ast An expression tree with a ConditionalExpression as
  *      the top node
  * @private
  */
 export function ConditionalExpression(this: Evaluator, ast: any) {
-  return this.eval(ast.test).then((res: any) => {
-    if (res) {
-      if (ast.consequent) {
-        return this.eval(ast.consequent)
-      }
-      return res
-    }
-    return this.eval(ast.alternate)
-  })
+  const res = this.eval(ast.test)
+  if (res) {
+    return ast.consequent ? this.eval(ast.consequent) : res
+  }
+  return this.eval(ast.alternate)
 }
 
 /**
- * Evaluates a FilterExpression by applying it to the subject value.
+ * Evaluates a FilterExpression by applying bracket notation for array/object access.
+ * Note: Relative filtering (with leading dot) is not supported.
  * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
  *      subject: {}}} ast An expression tree with a FilterExpression as the top
  *      node
- * @returns {Promise<*>} resolves with the value of the FilterExpression.
+ * @returns {*} the value at the specified index/property.
  * @private
  */
 export function FilterExpression(this: Evaluator, ast: any) {
-  return this.eval(ast.subject).then((subject: any) => {
-    if (ast.relative) {
-      return this._filterRelative(subject, ast.expr)
-    }
-    return this._filterStatic(subject, ast.expr)
-  })
+  const subject = this.eval(ast.subject)
+  if (ast.relative) {
+    throw new Error('Relative filter expressions are not supported')
+  }
+  const index = this.eval(ast.expr)
+  return subject?.[index]
 }
 
 /**
@@ -93,8 +89,7 @@ export function FilterExpression(this: Evaluator, ast: any) {
  * constructed.
  * @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
  *      tree with an Identifier as the top node
- * @returns {Promise<*>|*} either the identifier's value, or a Promise that
- *      will resolve with the identifier's value.
+ * @returns {*} the identifier's value.
  * @private
  */
 export function Identifier(this: Evaluator, ast: any) {
@@ -102,13 +97,12 @@ export function Identifier(this: Evaluator, ast: any) {
     const contextSource = ast.relative ? this._relContext : this._context
     return contextSource[ast.value]
   }
-  return this.eval(ast.from).then((context: any) => {
-    if (context == null) {
-      return undefined
-    }
-    const ctx = Array.isArray(context) ? context[0] : context
-    return ctx?.[ast.value]
-  })
+  const context = this.eval(ast.from)
+  if (context == null) {
+    return undefined
+  }
+  const ctx = Array.isArray(context) ? context[0] : context
+  return ctx?.[ast.value]
 }
 
 /**
@@ -127,23 +121,22 @@ export function Literal(this: Evaluator, ast: any) {
  * and concatenating all parts into a final string.
  * @param {{type: 'TemplateLiteral', parts: Array<{}>}} ast An expression
  *      tree with a TemplateLiteral as the top node
- * @returns {Promise<string>} resolves with the final interpolated string
+ * @returns {string} the final interpolated string
  * @private
  */
 export function TemplateLiteral(this: Evaluator, ast: any) {
-  const promises = ast.parts.map((part: any) => {
+  const values = ast.parts.map((part: any) => {
     if (part.type === 'static') {
-      return this.Promise.resolve(part.value)
+      return part.value
     }
-    return this.eval(part.value).then((result: any) => {
-      if (result == null) {
-        return ''
-      }
-      return String(result)
-    })
+    const result = this.eval(part.value)
+    if (result == null) {
+      return ''
+    }
+    return String(result)
   })
 
-  return this.Promise.all(promises).then((values: string[]) => values.join(''))
+  return values.join('')
 }
 
 /**
@@ -151,7 +144,7 @@ export function TemplateLiteral(this: Evaluator, ast: any) {
  * independently run through the evaluator.
  * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
  *      ObjectLiteral as the top node
- * @returns {Promise<{}>} resolves to a map contained evaluated values.
+ * @returns {{}} a map of evaluated values.
  * @private
  */
 export function ObjectLiteral(this: Evaluator, ast: any) {
@@ -163,8 +156,7 @@ export function ObjectLiteral(this: Evaluator, ast: any) {
  * function defined in one of the grammar's function pools.
  * @param {{type: 'FunctionCall', name: <string>}} ast An
  *      expression tree with a FunctionCall as the top node
- * @returns {Promise<*>|*} the value of the function call, or a Promise that
- *      will resolve with the resulting value.
+ * @returns {*} the value of the function call.
  * @private
  */
 export function FunctionCall(this: Evaluator, ast: any) {
@@ -177,7 +169,8 @@ export function FunctionCall(this: Evaluator, ast: any) {
   if (!func) {
     throw new Error(`${poolName} ${ast.name} is not defined.`)
   }
-  return this.evalArray(ast.args || []).then((args: any[]) => func(...args))
+  const args = this.evalArray(ast.args || [])
+  return func(...args)
 }
 
 /**
@@ -185,13 +178,12 @@ export function FunctionCall(this: Evaluator, ast: any) {
  * operator's eval function.
  * @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
  *      expression tree with a UnaryExpression as the top node
- * @returns {Promise<*>} resolves with the value of the UnaryExpression.
+ * @returns {*} the value of the UnaryExpression.
  * @constructor
  */
 export function UnaryExpression(this: Evaluator, ast: any) {
-  return this.eval(ast.right).then((right: any) =>
-    this._grammar.elements[ast.operator].eval(right)
-  )
+  const right = this.eval(ast.right)
+  return this._grammar.elements[ast.operator].eval(right)
 }
 
 /**
@@ -200,17 +192,12 @@ export function UnaryExpression(this: Evaluator, ast: any) {
  */
 export function SequenceExpression(this: Evaluator, ast: any) {
   let lastValue: any
-  let promise = this.Promise.resolve()
 
   for (const expr of ast.expressions) {
-    promise = promise.then(() =>
-      this.eval(expr).then((val: any) => {
-        lastValue = val
-      })
-    )
+    lastValue = this.eval(expr)
   }
 
-  return promise.then(() => lastValue)
+  return lastValue
 }
 
 /**
@@ -218,9 +205,8 @@ export function SequenceExpression(this: Evaluator, ast: any) {
  * and assigning it to the variable name on the left side.
  */
 export function AssignmentExpression(this: Evaluator, ast: any) {
-  return this.eval(ast.right).then((value: any) => {
-    const varName = ast.left.value
-    this._context[varName] = value
-    return value
-  })
+  const value = this.eval(ast.right)
+  const varName = ast.left.value
+  this._context[varName] = value
+  return value
 }

package/src/grammar.ts

@@ -9,7 +9,7 @@ export interface BinaryOp {
   type: 'binaryOp'
   precedence: number
   eval?: (left: any, right: any) => any
-  evalOnDemand?: (left: { eval: () => Promise<any> }, right: { eval: () => Promise<any> }) => Promise<any>
+  evalOnDemand?: (left: { eval: () => any }, right: { eval: () => any }) => any
 }
 
 export interface UnaryOp {
@@ -27,7 +27,6 @@ export type GrammarElement = BinaryOp | UnaryOp | SimpleElement
 export interface Grammar {
   elements: Record<string, GrammarElement>
   functions: Record<string, (...args: any[]) => any>
-  transforms: Record<string, (val: any, ...args: any[]) => any>
 }
 
 export const getGrammar = (): Grammar => ({
@@ -40,7 +39,6 @@ export const getGrammar = (): Grammar => ({
     '.': { type: 'dot' },
     '[': { type: 'openBracket' },
     ']': { type: 'closeBracket' },
-    '|': { type: 'pipe' },
     '{': { type: 'openCurl' },
     '}': { type: 'closeCurl' },
     ':': { type: 'colon' },
@@ -118,20 +116,22 @@ export const getGrammar = (): Grammar => ({
       type: 'binaryOp',
       precedence: 10,
       evalOnDemand: (left, right) => {
-        return left.eval().then((leftVal) => {
-          if (!leftVal) {return leftVal}
-          return right.eval()
-        })
+        const leftVal = left.eval()
+        if (!leftVal) {
+          return leftVal
+        }
+        return right.eval()
       }
     },
     '||': {
       type: 'binaryOp',
       precedence: 10,
       evalOnDemand: (left, right) => {
-        return left.eval().then((leftVal) => {
-          if (leftVal) {return leftVal}
-          return right.eval()
-        })
+        const leftVal = left.eval()
+        if (leftVal) {
+          return leftVal
+        }
+        return right.eval()
       }
     },
     in: {
@@ -169,32 +169,11 @@ export const getGrammar = (): Grammar => ({
    *       All of these are pre-evaluated to their actual values before calling
    *       the function.
    *
-   * The Jexl function should return either the transformed value, or
-   * a Promises/A+ Promise object that resolves with the value and rejects
-   * or throws only when an unrecoverable error occurs. Functions should
-   * generally return undefined when they don't make sense to be used on the
-   * given value type, rather than throw/reject. An error is only
-   * appropriate when the function would normally return a value, but
-   * cannot due to some other failure.
-   */
-  functions: {},
-
-  /**
-   * A map of transform names to transform functions. A transform function
-   * takes one ore more arguemnts:
-   *
-   *     - {*} val: A value to be transformed
-   *     - {*} ...args: A variable number of arguments passed to this transform.
-   *       All of these are pre-evaluated to their actual values before calling
-   *       the function.
-   *
-   * The transform function should return either the transformed value, or
-   * a Promises/A+ Promise object that resolves with the value and rejects
-   * or throws only when an unrecoverable error occurs. Transforms should
-   * generally return undefined when they don't make sense to be used on the
-   * given value type, rather than throw/reject. An error is only
-   * appropriate when the transform would normally return a value, but
-   * cannot due to some other failure.
+   * The Jexl function should return the resulting value, or throw when an
+   * unrecoverable error occurs. Functions should generally return undefined
+   * when they don't make sense to be used on the given value type, rather
+   * than throw. An error is only appropriate when the function would normally
+   * return a value, but cannot due to some other failure.
    */
-  transforms: {}
+  functions: {}
 })

package/src/types.ts

@@ -104,4 +104,7 @@ export type AstNodeUnion =
   | SequenceExpression
   | AssignmentExpression
 
-export type NodeByType<T extends AstNodeUnion['type']> = Extract<AstNodeUnion, { type: T }>
+export type NodeByType<T extends AstNodeUnion['type']> = Extract<
+  AstNodeUnion,
+  { type: T }
+>

package/dist/PromiseSync.d.ts

@@ -1,13 +0,0 @@
-declare class PromiseSync<T = unknown> {
-    value?: T;
-    error?: unknown;
-    constructor(fn: (resolve: (val: T) => void, reject: (error: unknown) => void) => void);
-    catch<TResult = never>(rejected: (error: unknown) => TResult): PromiseSync<T | TResult>;
-    then<TResult1 = T, TResult2 = never>(resolved: (val: T) => TResult1, rejected?: (error: unknown) => TResult2): PromiseSync<TResult1 | TResult2>;
-    _reject(error: unknown): void;
-    _resolve(val: any): void;
-    static all<T>(vals: (PromiseSync<T> | T)[]): PromiseSync<T[]>;
-    static resolve<T>(val?: T): PromiseSync<T>;
-    static reject(error: unknown): PromiseSync<never>;
-}
-export default PromiseSync;

package/dist/PromiseSync.js

@@ -1,80 +0,0 @@
-"use strict";
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-class PromiseSync {
-    constructor(fn) {
-        fn(this._resolve.bind(this), this._reject.bind(this));
-    }
-    catch(rejected) {
-        if (this.error) {
-            try {
-                this._resolve(rejected(this.error));
-            }
-            catch (e) {
-                this._reject(e);
-            }
-        }
-        return this;
-    }
-    // eslint-disable-next-line unicorn/no-thenable
-    then(resolved, rejected) {
-        if (!this.error) {
-            try {
-                this._resolve(resolved(this.value));
-            }
-            catch (e) {
-                this._reject(e);
-            }
-        }
-        if (rejected) {
-            this.catch(rejected);
-        }
-        return this;
-    }
-    _reject(error) {
-        this.value = undefined;
-        this.error = error;
-    }
-    _resolve(val) {
-        if (val instanceof PromiseSync) {
-            if (val.error) {
-                this._reject(val.error);
-            }
-            else {
-                this._resolve(val.value);
-            }
-        }
-        else {
-            this.value = val;
-            this.error = undefined;
-        }
-    }
-    static all(vals) {
-        return new PromiseSync((resolve) => {
-            const resolved = vals.map((val) => {
-                while (val instanceof PromiseSync) {
-                    if (val.error) {
-                        if (val.error instanceof Error) {
-                            throw val.error;
-                        }
-                        throw new Error(typeof val.error === 'string' ? val.error : JSON.stringify(val.error));
-                    }
-                    val = val.value;
-                }
-                return val;
-            });
-            resolve(resolved);
-        });
-    }
-    static resolve(val) {
-        return new PromiseSync((resolve) => { resolve(val); });
-    }
-    static reject(error) {
-        return new PromiseSync((_, reject) => { reject(error); });
-    }
-}
-exports.default = PromiseSync;
-//# sourceMappingURL=PromiseSync.js.map

package/dist/PromiseSync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PromiseSync.js","sourceRoot":"","sources":["../src/PromiseSync.ts"],"names":[],"mappings":"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"}

package/esm/PromiseSync.d.ts

@@ -1,13 +0,0 @@
-declare class PromiseSync<T = unknown> {
-    value?: T;
-    error?: unknown;
-    constructor(fn: (resolve: (val: T) => void, reject: (error: unknown) => void) => void);
-    catch<TResult = never>(rejected: (error: unknown) => TResult): PromiseSync<T | TResult>;
-    then<TResult1 = T, TResult2 = never>(resolved: (val: T) => TResult1, rejected?: (error: unknown) => TResult2): PromiseSync<TResult1 | TResult2>;
-    _reject(error: unknown): void;
-    _resolve(val: any): void;
-    static all<T>(vals: (PromiseSync<T> | T)[]): PromiseSync<T[]>;
-    static resolve<T>(val?: T): PromiseSync<T>;
-    static reject(error: unknown): PromiseSync<never>;
-}
-export default PromiseSync;