@jbrowse/jexl 2.3.1

package/dist/Jexl.d.ts

@@ -0,0 +1,148 @@
+import Expression from './Expression.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
+ */
+declare class Jexl {
+    _grammar: Grammar;
+    constructor();
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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>): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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>): void;
+    /**
+     * 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): Expression;
+    /**
+     * 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): Expression;
+    /**
+     * Retrieves a previously set expression function.
+     * @param {string} name The name of the expression function
+     * @returns {function} The expression function
+     */
+    getFunction(name: string): (...args: any[]) => any;
+    /**
+     * Retrieves a previously set transform function.
+     * @param {string} name The name of the transform function
+     * @returns {function} The transform function
+     */
+    getTransform(name: string): (val: any, ...args: any[]) => any;
+    /**
+     * 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?: {}): Promise<any> | import("./PromiseSync.ts").default<any>;
+    /**
+     * 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?: {}): unknown;
+    /**
+     * 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[]): Expression;
+    /**
+     * Removes a binary or unary operator from the Jexl grammar.
+     * @param {string} operator The operator string to be removed
+     */
+    removeOp(operator: string): void;
+    /**
+     * 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): void;
+}
+declare const jexlInstance: Jexl;
+export default jexlInstance;
+export { Jexl };

package/dist/Jexl.js

@@ -0,0 +1,208 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jexl = void 0;
+const Expression_ts_1 = __importDefault(require("./Expression.js"));
+const grammar_ts_1 = require("./grammar.js");
+/**
+ * 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 {
+    constructor() {
+        this._grammar = (0, grammar_ts_1.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, precedence, fn, manualEval) {
+        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, fn) {
+        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) {
+        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, fn) {
+        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, fn) {
+        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) {
+        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) {
+        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) {
+        return new Expression_ts_1.default(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) {
+        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) {
+        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, 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, 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, ...args) {
+        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) {
+        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, obj) {
+        this._grammar.elements[str] = obj;
+    }
+}
+exports.Jexl = Jexl;
+const jexlInstance = new Jexl();
+exports.default = jexlInstance;
+//# sourceMappingURL=Jexl.js.map

package/dist/Jexl.js.map

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

package/dist/Lexer.d.ts

@@ -0,0 +1,130 @@
+import type { Token } from './types.ts';
+interface Grammar {
+    elements: Record<string, any>;
+}
+/**
+ * Lexer is a collection of stateless, statically-accessed functions for the
+ * lexical parsing of a Jexl string.  Its responsibility is to identify the
+ * "parts of speech" of a Jexl expression, and tokenize and label each, but
+ * to do only the most minimal syntax checking; the only errors the Lexer
+ * should be concerned with are if it's unable to identify the utility of
+ * any of its tokens.  Errors stemming from these tokens not being in a
+ * sensible configuration should be left for the Parser to handle.
+ * @type {{}}
+ */
+declare class Lexer {
+    _grammar: Grammar;
+    _splitRegex?: RegExp;
+    _escQuoteRegexCache: Map<string, RegExp>;
+    constructor(grammar: Grammar);
+    /**
+     * Splits a Jexl expression string into an array of expression elements.
+     * @param {string} str A Jexl expression string
+     * @returns {Array<string>} An array of substrings defining the functional
+     *      elements of the expression.
+     */
+    getElements(str: string): string[];
+    /**
+     * Converts an array of expression elements into an array of tokens.  Note that
+     * the resulting array may not equal the element array in length, as any
+     * elements that consist only of whitespace get appended to the previous
+     * token's "raw" property.  For the structure of a token object, please see
+     * {@link Lexer#tokenize}.
+     * @param {Array<string>} elements An array of Jexl expression elements to be
+     *      converted to tokens
+     * @returns {Array<{type, value, raw}>} an array of token objects.
+     */
+    getTokens(elements: string[]): Token[];
+    /**
+     * Converts a Jexl string into an array of tokens.  Each token is an object
+     * in the following format:
+     *
+     *     {
+     *         type: <string>,
+     *         [name]: <string>,
+     *         value: <boolean|number|string>,
+     *         raw: <string>
+     *     }
+     *
+     * Type is one of the following:
+     *
+     *      literal, identifier, binaryOp, unaryOp
+     *
+     * OR, if the token is a control character its type is the name of the element
+     * defined in the Grammar.
+     *
+     * Name appears only if the token is a control string found in
+     * {@link grammar#elements}, and is set to the name of the element.
+     *
+     * Value is the value of the token in the correct type (boolean or numeric as
+     * appropriate). Raw is the string representation of this value taken directly
+     * from the expression string, including any trailing spaces.
+     * @param {string} str The Jexl string to be tokenized
+     * @returns {Array<{type, value, raw}>} an array of token objects.
+     * @throws {Error} if the provided string contains an invalid token.
+     */
+    tokenize(str: string): Token[];
+    /**
+     * Creates a new token object from an element of a Jexl string. See
+     * {@link Lexer#tokenize} for a description of the token object.
+     * @param {string} element The element from which a token should be made
+     * @returns {{value: number|boolean|string, [name]: string, type: string,
+     *      raw: string}} a token object describing the provided element.
+     * @throws {Error} if the provided string is not a valid expression element.
+     * @private
+     */
+    _createToken(element: string): Token;
+    /**
+     * Escapes a string so that it can be treated as a string literal within a
+     * regular expression.
+     * @param {string} str The string to be escaped
+     * @returns {string} the RegExp-escaped string.
+     * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions
+     * @private
+     */
+    _escapeRegExp(str: string): string;
+    /**
+     * Gets a RegEx object appropriate for splitting a Jexl string into its core
+     * elements.
+     * @returns {RegExp} An element-splitting RegExp object
+     * @private
+     */
+    _getSplitRegex(): RegExp;
+    /**
+     * Determines whether the addition of a '-' token should be interpreted as a
+     * negative symbol for an upcoming number, given an array of tokens already
+     * processed.
+     * @param {Array<Object>} tokens An array of tokens already processed
+     * @returns {boolean} true if adding a '-' should be considered a negative
+     *      symbol; false otherwise
+     * @private
+     */
+    _isNegative(tokens: Token[]): boolean;
+    /**
+     * A utility function to determine if a string consists of only space
+     * characters.
+     * @param {string} str A string to be tested
+     * @returns {boolean} true if the string is empty or consists of only spaces;
+     *      false otherwise.
+     * @private
+     */
+    _isWhitespace(str: string): boolean;
+    /**
+     * Removes the beginning and trailing quotes from a string, unescapes any
+     * escaped quotes on its interior, and unescapes any escaped escape
+     * characters. Note that this function is not defensive; it assumes that the
+     * provided string is not empty, and that its first and last characters are
+     * actually quotes.
+     * @param {string} str A string whose first and last characters are quotes
+     * @returns {string} a string with the surrounding quotes stripped and escapes
+     *      properly processed.
+     * @private
+     */
+    _unquote(str: string): string;
+    _parseTemplateString(str: string): {
+        type: "static" | "interpolation";
+        value: string;
+    }[];
+    _unescapeTemplateString(str: string): string;
+}
+export default Lexer;