@jbrowse/jexl 2.3.1

package/esm/parser/states.js

@@ -0,0 +1,159 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+import * as h from "./handlers.js";
+/**
+ * A mapping of all states in the finite state machine to a set of instructions
+ * for handling or transitioning into other states. Each state can be handled
+ * in one of two schemes: a tokenType map, or a subHandler.
+ *
+ * Standard expression elements are handled through the tokenType object. This
+ * is an object map of all legal token types to encounter in this state (and
+ * any unexpected token types will generate a thrown error) to an options
+ * object that defines how they're handled.  The available options are:
+ *
+ *      {string} toState: The name of the state to which to transition
+ *          immediately after handling this token
+ *      {string} handler: The handler function to call when this token type is
+ *          encountered in this state.  If omitted, the default handler
+ *          matching the token's "type" property will be called. If the handler
+ *          function does not exist, no call will be made and no error will be
+ *          generated.  This is useful for tokens whose sole purpose is to
+ *          transition to other states.
+ *
+ * States that consume a subexpression should define a subHandler, the
+ * function to be called with an expression tree argument when the
+ * subexpression is complete. Completeness is determined through the
+ * endStates object, which maps tokens on which an expression should end to the
+ * state to which to transition once the subHandler function has been called.
+ *
+ * Additionally, any state in which it is legal to mark the AST as completed
+ * should have a 'completable' property set to boolean true.  Attempting to
+ * call {@link Parser#complete} in any state without this property will result
+ * in a thrown Error.
+ *
+ * @type {{}}
+ */
+export const states = {
+    expectOperand: {
+        tokenTypes: {
+            literal: { toState: 'expectBinOp' },
+            templateString: { toState: 'expectBinOp' },
+            identifier: { toState: 'identifier' },
+            unaryOp: {},
+            openParen: { toState: 'subExpression' },
+            openCurl: { toState: 'expectObjKey', handler: h.objStart },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'arrayVal', handler: h.arrayStart }
+        }
+    },
+    expectBinOp: {
+        tokenTypes: {
+            binaryOp: { toState: 'expectOperand' },
+            pipe: { toState: 'expectTransform' },
+            dot: { toState: 'traverse' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart },
+            semicolon: { handler: h.semicolon }
+        },
+        completable: true
+    },
+    expectTransform: {
+        tokenTypes: {
+            identifier: { toState: 'postTransform', handler: h.transform }
+        }
+    },
+    expectObjKey: {
+        tokenTypes: {
+            literal: { toState: 'expectKeyValSep', handler: h.objKey },
+            identifier: { toState: 'expectKeyValSep', handler: h.objKey },
+            closeCurl: { toState: 'expectBinOp' }
+        }
+    },
+    expectKeyValSep: {
+        tokenTypes: {
+            colon: { toState: 'objVal' }
+        }
+    },
+    postTransform: {
+        tokenTypes: {
+            openParen: { toState: 'argVal' },
+            binaryOp: { toState: 'expectOperand' },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'filter' },
+            pipe: { toState: 'expectTransform' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart }
+        },
+        completable: true
+    },
+    postArgs: {
+        tokenTypes: {
+            binaryOp: { toState: 'expectOperand' },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'filter' },
+            pipe: { toState: 'expectTransform' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart }
+        },
+        completable: true
+    },
+    identifier: {
+        tokenTypes: {
+            binaryOp: { toState: 'expectOperand' },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'filter' },
+            openParen: { toState: 'argVal', handler: h.functionCall },
+            pipe: { toState: 'expectTransform' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart }
+        },
+        completable: true
+    },
+    traverse: {
+        tokenTypes: {
+            identifier: { toState: 'identifier' }
+        }
+    },
+    filter: {
+        subHandler: h.filter,
+        endStates: {
+            closeBracket: 'identifier'
+        }
+    },
+    subExpression: {
+        subHandler: h.subExpression,
+        endStates: {
+            closeParen: 'expectBinOp'
+        }
+    },
+    argVal: {
+        subHandler: h.argVal,
+        endStates: {
+            comma: 'argVal',
+            closeParen: 'postArgs'
+        }
+    },
+    objVal: {
+        subHandler: h.objVal,
+        endStates: {
+            comma: 'expectObjKey',
+            closeCurl: 'expectBinOp'
+        }
+    },
+    arrayVal: {
+        subHandler: h.arrayVal,
+        endStates: {
+            comma: 'arrayVal',
+            closeBracket: 'expectBinOp'
+        }
+    },
+    ternaryMid: {
+        subHandler: h.ternaryMid,
+        endStates: {
+            colon: 'ternaryEnd'
+        }
+    },
+    ternaryEnd: {
+        subHandler: h.ternaryEnd,
+        completable: true
+    }
+};
+//# sourceMappingURL=states.js.map

package/esm/parser/states.js.map

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

package/esm/types.d.ts

@@ -0,0 +1,77 @@
+export interface Token {
+    type: string;
+    value: any;
+    raw: string;
+}
+export interface AstNode {
+    type: string;
+    _parent?: AstNode;
+}
+export interface Literal extends AstNode {
+    type: 'Literal';
+    value: string | number | boolean;
+}
+export interface Identifier extends AstNode {
+    type: 'Identifier';
+    value: string;
+    from?: AstNode;
+    relative?: boolean;
+}
+export interface BinaryExpression extends AstNode {
+    type: 'BinaryExpression';
+    operator: string;
+    left: AstNode;
+    right?: AstNode;
+}
+export interface UnaryExpression extends AstNode {
+    type: 'UnaryExpression';
+    operator: string;
+    right?: AstNode;
+}
+export interface ArrayLiteral extends AstNode {
+    type: 'ArrayLiteral';
+    value: AstNode[];
+}
+export interface ObjectLiteral extends AstNode {
+    type: 'ObjectLiteral';
+    value: Record<string, AstNode>;
+}
+export interface TemplateLiteral extends AstNode {
+    type: 'TemplateLiteral';
+    parts: {
+        type: 'static' | 'expression';
+        value: string | AstNode;
+    }[];
+}
+export interface FunctionCall extends AstNode {
+    type: 'FunctionCall';
+    name: string;
+    args: AstNode[];
+    pool: 'functions' | 'transforms';
+}
+export interface FilterExpression extends AstNode {
+    type: 'FilterExpression';
+    expr: AstNode;
+    relative: boolean;
+    subject: AstNode;
+}
+export interface ConditionalExpression extends AstNode {
+    type: 'ConditionalExpression';
+    test: AstNode;
+    consequent?: AstNode;
+    alternate?: AstNode;
+}
+export interface SequenceExpression extends AstNode {
+    type: 'SequenceExpression';
+    expressions: AstNode[];
+}
+export interface AssignmentExpression extends AstNode {
+    type: 'AssignmentExpression';
+    operator: '=';
+    left: Identifier;
+    right: AstNode;
+}
+export type AstNodeUnion = Literal | Identifier | BinaryExpression | UnaryExpression | ArrayLiteral | ObjectLiteral | TemplateLiteral | FunctionCall | FilterExpression | ConditionalExpression | SequenceExpression | AssignmentExpression;
+export type NodeByType<T extends AstNodeUnion['type']> = Extract<AstNodeUnion, {
+    type: T;
+}>;

package/esm/types.js

@@ -0,0 +1,6 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@jbrowse/jexl",
+  "version": "2.3.1",
+  "description": "A fork of the jexl lang for jbrowse",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "import": {
+      "import": "./esm/index.js"
+    },
+    "require": {
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "esm",
+    "src"
+  ],
+  "scripts": {
+    "format": "prettier --write .",
+    "lint": "eslint --report-unused-disable-directives --max-warnings 0",
+    "test": "vitest",
+    "clean": "rimraf dist esm",
+    "build:esm": "tsc --outDir esm",
+    "build:es5": "tsc --module commonjs --outDir dist",
+    "build": "yarn build:esm && yarn build:es5",
+    "prebuild": "yarn clean",
+    "postbuild:es5": "echo '{\"type\": \"commonjs\"}' > dist/package.json",
+    "preversion": "yarn lint && yarn test --run && yarn build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TomFrost/jexl"
+  },
+  "keywords": [
+    "JSON",
+    "expression",
+    "evaluator",
+    "parser",
+    "target",
+    "context",
+    "jsep",
+    "filter",
+    "selector"
+  ],
+  "author": "Tom Shawver <tom@frosteddesign.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/TomFrost/jexl/issues"
+  },
+  "homepage": "https://github.com/TomFrost/jexl",
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "eslint": "^9.39.2",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "prettier": "^3.7.4",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.50.1",
+    "vitest": "^4.0.16"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/Expression.ts

@@ -0,0 +1,95 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+
+import Lexer from './Lexer.ts'
+import PromiseSync from './PromiseSync.ts'
+import Evaluator from './evaluator/Evaluator.ts'
+import Parser from './parser/Parser.ts'
+
+import type { AstNode } from './types.ts'
+
+interface Grammar {
+  elements: Record<string, any>
+  [key: string]: any
+}
+
+type PromiseConstructor = typeof Promise | typeof PromiseSync
+
+class Expression {
+  _grammar: Grammar
+  _exprStr: string
+  _ast: AstNode | null
+
+  constructor(grammar: Grammar, exprStr: string) {
+    this._grammar = grammar
+    this._exprStr = exprStr
+    this._ast = null
+  }
+
+  /**
+   * Forces a compilation of the expression string that this Expression object
+   * was constructed with. This function can be called multiple times; useful
+   * if the language elements of the associated Jexl instance change.
+   * @returns {Expression} this Expression instance, for convenience
+   */
+  compile() {
+    const lexer = new Lexer(this._grammar)
+    const parser = new Parser(this._grammar, lexer)
+    const tokens = lexer.tokenize(this._exprStr)
+    parser.addTokens(tokens)
+    this._ast = parser.complete()
+    return this
+  }
+
+  /**
+   * 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.
+   * @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!)
+    })
+  }
+
+  _getAst() {
+    if (!this._ast) {
+      this.compile()
+    }
+    return this._ast
+  }
+}
+
+export default Expression

package/src/Jexl.ts

@@ -0,0 +1,232 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+
+import Expression from './Expression.ts'
+import { getGrammar } from './grammar.ts'
+
+interface Grammar {
+  elements: Record<string, any>
+  functions: Record<string, (...args: any[]) => any>
+  transforms: Record<string, (val: any, ...args: any[]) => any>
+}
+
+/**
+ * Jexl is the Javascript Expression Language, capable of parsing and
+ * evaluating basic to complex expression strings, combined with advanced
+ * xpath-like drilldown into native Javascript objects.
+ * @constructor
+ */
+class Jexl {
+  _grammar: Grammar
+
+  constructor() {
+    this._grammar = getGrammar()
+    this.expr = this.expr.bind(this)
+  }
+
+  /**
+   * Adds a binary operator to Jexl at the specified precedence. The higher the
+   * precedence, the earlier the operator is applied in the order of operations.
+   * For example, * has a higher precedence than +, because multiplication comes
+   * before division.
+   *
+   * Please see grammar.js for a listing of all default operators and their
+   * precedence values in order to choose the appropriate precedence for the
+   * new operator.
+   * @param {string} operator The operator string to be added
+   * @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.
+   * @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.
+   */
+  addBinaryOp(
+    operator: string,
+    precedence: number,
+    fn: (left: any, right: any) => any,
+    manualEval?: boolean
+  ) {
+    this._addGrammarElement(operator, {
+      type: 'binaryOp',
+      precedence: precedence,
+      [manualEval ? 'evalOnDemand' : 'eval']: fn
+    })
+  }
+
+  /**
+   * Adds or replaces an expression function in this Jexl instance.
+   * @param {string} name The name of the expression function, as it will be
+   *      used within Jexl expressions
+   * @param {function} fn The javascript function to be executed when this
+   *      expression function is invoked. It will be provided with each argument
+   *      supplied in the expression, in the same order.
+   */
+  addFunction(name: string, fn: (...args: any[]) => any) {
+    this._grammar.functions[name] = fn
+  }
+
+  /**
+   * Syntactic sugar for calling {@link #addFunction} repeatedly. This function
+   * accepts a map of one or more expression function names to their javascript
+   * function counterpart.
+   * @param {{}} map A map of expression function names to javascript functions
+   */
+  addFunctions(map: Record<string, (...args: any[]) => any>) {
+    Object.assign(this._grammar.functions, map)
+  }
+
+  /**
+   * Adds a unary operator to Jexl. Unary operators are currently only supported
+   * on the left side of the value on which it will operate.
+   * @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.
+   */
+  addUnaryOp(operator: string, fn: (right: any) => any) {
+    this._addGrammarElement(operator, {
+      type: 'unaryOp',
+      weight: Infinity,
+      eval: fn
+    })
+  }
+
+  /**
+   * Adds or replaces a transform function in this Jexl instance.
+   * @param {string} name The name of the transform function, as it will be used
+   *      within Jexl expressions
+   * @param {function} fn The function to be executed when this transform is
+   *      invoked. It will be provided with at least one argument:
+   *          - {*} value: The value to be transformed
+   *          - {...*} args: The arguments for this transform
+   */
+  addTransform(name: string, fn: (val: any, ...args: any[]) => any) {
+    this._grammar.transforms[name] = fn
+  }
+
+  /**
+   * Syntactic sugar for calling {@link #addTransform} repeatedly.  This function
+   * accepts a map of one or more transform names to their transform function.
+   * @param {{}} map A map of transform names to transform functions
+   */
+  addTransforms(map: Record<string, (val: any, ...args: any[]) => any>) {
+    Object.assign(this._grammar.transforms, map)
+  }
+
+  /**
+   * Creates an Expression object from the given Jexl expression string, and
+   * immediately compiles it. The returned Expression object can then be
+   * evaluated multiple times with new contexts, without generating any
+   * additional string processing overhead.
+   * @param {string} expression The Jexl expression to be compiled
+   * @returns {Expression} The compiled Expression object
+   */
+  compile(expression: string) {
+    const exprObj = this.createExpression(expression)
+    return exprObj.compile()
+  }
+
+  /**
+   * Constructs an Expression object from a Jexl expression string.
+   * @param {string} expression The Jexl expression to be wrapped in an
+   *    Expression object
+   * @returns {Expression} The Expression object representing the given string
+   */
+  createExpression(expression: string) {
+    return new Expression(this._grammar, expression)
+  }
+
+  /**
+   * Retrieves a previously set expression function.
+   * @param {string} name The name of the expression function
+   * @returns {function} The expression function
+   */
+  getFunction(name: string) {
+    return this._grammar.functions[name]
+  }
+
+  /**
+   * Retrieves a previously set transform function.
+   * @param {string} name The name of the transform function
+   * @returns {function} The transform function
+   */
+  getTransform(name: string) {
+    return this._grammar.transforms[name]
+  }
+
+  /**
+   * 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.
+   * @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 = {}) {
+    const exprObj = this.createExpression(expression)
+    return exprObj.evalSync(context)
+  }
+
+  /**
+   * A JavaScript template literal to allow expressions to be defined by the
+   * syntax: expr`40 + 2`
+   * @param {Array<string>} strs
+   * @param  {...any} args
+   */
+  expr(strs: TemplateStringsArray, ...args: any[]) {
+    let exprStr = ''
+    for (let idx = 0; idx < strs.length; idx++) {
+      exprStr += strs[idx]
+      if (idx < args.length) {
+        exprStr += args[idx]
+      }
+    }
+    return this.createExpression(exprStr)
+  }
+
+  /**
+   * Removes a binary or unary operator from the Jexl grammar.
+   * @param {string} operator The operator string to be removed
+   */
+  removeOp(operator: string) {
+    const elem = this._grammar.elements[operator]
+    if (elem && (elem.type === 'binaryOp' || elem.type === 'unaryOp')) {
+      Reflect.deleteProperty(this._grammar.elements, operator)
+    }
+  }
+
+  /**
+   * Adds an element to the grammar map used by this Jexl instance.
+   * @param {string} str The key string to be added
+   * @param {{type: <string>}} obj A map of configuration options for this
+   *      grammar element
+   * @private
+   */
+  _addGrammarElement(str: string, obj: any) {
+    this._grammar.elements[str] = obj
+  }
+}
+
+const jexlInstance = new Jexl()
+export default jexlInstance
+export { Jexl }