@jbrowse/jexl 2.3.1

package/dist/Lexer.js

@@ -0,0 +1,321 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const numericRegex = /^-?(?:(?:[0-9]*\.[0-9]+)|[0-9]+)$/;
+const identRegex = /^[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][a-zA-Zа-яА-Я0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*$/;
+const escEscRegex = /\\\\/;
+const whitespaceRegex = /^\s*$/;
+const preOpRegexElems = [
+    // Template strings
+    '`(?:[^`\\\\]|\\\\.)*`',
+    // Strings
+    String.raw `'(?:(?:\\')|[^'])*'`,
+    String.raw `"(?:(?:\\")|[^"])*"`,
+    // Whitespace
+    String.raw `\s+`,
+    // Booleans
+    String.raw `\btrue\b`,
+    String.raw `\bfalse\b`
+];
+const postOpRegexElems = [
+    // Identifiers
+    '[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF\\$][a-zA-Z0-9а-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF\\$]*',
+    // Numerics (without negative symbol)
+    String.raw `(?:(?:[0-9]*\.[0-9]+)|[0-9]+)`
+];
+const minusNegatesAfter = new Set([
+    'binaryOp',
+    'unaryOp',
+    'openParen',
+    'openBracket',
+    'question',
+    'colon'
+]);
+/**
+ * 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 {{}}
+ */
+class Lexer {
+    constructor(grammar) {
+        this._escQuoteRegexCache = new Map();
+        this._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) {
+        const regex = this._getSplitRegex();
+        return str.split(regex).filter(Boolean);
+    }
+    /**
+     * 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) {
+        const tokens = [];
+        let negate = false;
+        for (let i = 0; i < elements.length; i++) {
+            if (this._isWhitespace(elements[i])) {
+                if (tokens.length) {
+                    tokens[tokens.length - 1].raw += elements[i];
+                }
+            }
+            else if (elements[i] === '-' && this._isNegative(tokens)) {
+                negate = true;
+            }
+            else {
+                if (negate) {
+                    elements[i] = '-' + elements[i];
+                    negate = false;
+                }
+                tokens.push(this._createToken(elements[i]));
+            }
+        }
+        // Catch a - at the end of the string. Let the parser handle that issue.
+        if (negate) {
+            tokens.push(this._createToken('-'));
+        }
+        return tokens;
+    }
+    /**
+     * 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) {
+        const elements = this.getElements(str);
+        return this.getTokens(elements);
+    }
+    /**
+     * 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) {
+        const token = {
+            type: 'literal',
+            value: element,
+            raw: element
+        };
+        if (element.startsWith('`')) {
+            token.type = 'templateString';
+            token.value = this._parseTemplateString(element);
+            return token;
+        }
+        else if (element.startsWith('"') || element.startsWith("'")) {
+            token.value = this._unquote(element);
+        }
+        else if (numericRegex.exec(element)) {
+            token.value = parseFloat(element);
+        }
+        else if (element === 'true' || element === 'false') {
+            token.value = element === 'true';
+        }
+        else if (this._grammar.elements[element]) {
+            token.type = this._grammar.elements[element].type;
+        }
+        else if (identRegex.exec(element)) {
+            token.type = 'identifier';
+        }
+        else {
+            throw new Error(`Invalid expression token: ${element}`);
+        }
+        return 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) {
+        str = str.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
+        if (identRegex.exec(str)) {
+            str = String.raw `\b` + str + String.raw `\b`;
+        }
+        return str;
+    }
+    /**
+     * Gets a RegEx object appropriate for splitting a Jexl string into its core
+     * elements.
+     * @returns {RegExp} An element-splitting RegExp object
+     * @private
+     */
+    _getSplitRegex() {
+        if (!this._splitRegex) {
+            // Sort by most characters to least, then regex escape each
+            const elemArray = Object.keys(this._grammar.elements)
+                .sort((a, b) => {
+                return b.length - a.length;
+            })
+                .map((elem) => {
+                return this._escapeRegExp(elem);
+            });
+            this._splitRegex = new RegExp('(' +
+                [
+                    preOpRegexElems.join('|'),
+                    elemArray.join('|'),
+                    postOpRegexElems.join('|')
+                ].join('|') +
+                ')');
+        }
+        return this._splitRegex;
+    }
+    /**
+     * 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) {
+        if (!tokens.length) {
+            return true;
+        }
+        return minusNegatesAfter.has(tokens[tokens.length - 1].type);
+    }
+    /**
+     * 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) {
+        return !!whitespaceRegex.exec(str);
+    }
+    /**
+     * 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) {
+        const quote = str[0];
+        let escQuoteRegex = this._escQuoteRegexCache.get(quote);
+        if (!escQuoteRegex) {
+            escQuoteRegex = new RegExp('\\\\' + quote, 'g');
+            this._escQuoteRegexCache.set(quote, escQuoteRegex);
+        }
+        return str
+            .slice(1, -1)
+            .replace(escQuoteRegex, quote)
+            .replace(escEscRegex, '\\');
+    }
+    _parseTemplateString(str) {
+        const parts = [];
+        let current = 1;
+        let staticStart = 1;
+        while (current < str.length - 1) {
+            if (str[current] === '\\') {
+                current += 2;
+                continue;
+            }
+            if (str[current] === '$' && str[current + 1] === '{') {
+                if (current > staticStart) {
+                    parts.push({
+                        type: 'static',
+                        value: str.slice(staticStart, current)
+                    });
+                }
+                let braceDepth = 1;
+                const interpStart = current + 2;
+                current += 2;
+                while (current < str.length && braceDepth > 0) {
+                    if (str[current] === '\\') {
+                        current += 2;
+                        continue;
+                    }
+                    if (str[current] === '{') {
+                        braceDepth++;
+                    }
+                    if (str[current] === '}') {
+                        braceDepth--;
+                    }
+                    current++;
+                }
+                if (braceDepth !== 0) {
+                    throw new Error(`Unclosed interpolation in template string: ${str}`);
+                }
+                parts.push({
+                    type: 'interpolation',
+                    value: str.slice(interpStart, current - 1)
+                });
+                staticStart = current;
+            }
+            else {
+                current++;
+            }
+        }
+        if (current > staticStart) {
+            parts.push({
+                type: 'static',
+                value: str.slice(staticStart, current)
+            });
+        }
+        return parts;
+    }
+    _unescapeTemplateString(str) {
+        return str
+            .replaceAll('\\`', '`')
+            .replaceAll(String.raw `\$`, '$')
+            .replaceAll('\\\\', '\\');
+    }
+}
+exports.default = Lexer;
+//# sourceMappingURL=Lexer.js.map

package/dist/Lexer.js.map

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

package/dist/PromiseSync.d.ts

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

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

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

package/dist/evaluator/Evaluator.d.ts

@@ -0,0 +1,92 @@
+import type { AstNode } from '../types.ts';
+interface Grammar {
+    elements: Record<string, any>;
+    [key: string]: any;
+}
+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
+ * collection of transforms, context, and a relative context to be used as the
+ * root for relative identifiers, are all specific to an Evaluator instance.
+ * When any of these things change, a new instance is required.  However, a
+ * single instance can be used to simultaneously evaluate many different
+ * expressions, and does not have to be reinstantiated for each.
+ * @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.
+ * @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.
+ */
+declare class Evaluator {
+    _grammar: Grammar;
+    _context: any;
+    _relContext: any;
+    Promise: PromiseConstructor;
+    constructor(grammar: Grammar, context?: any, relativeContext?: any, promise?: PromiseConstructor);
+    /**
+     * Evaluates an expression tree within the configured context.
+     * @param {{}} ast An expression tree object
+     * @returns {Promise<*>} resolves with the resulting value of the expression.
+     */
+    eval(ast: AstNode): any;
+    /**
+     * 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.
+     * @param {Array<string>} arr An array of expression strings to be evaluated
+     * @returns {Promise<Array<{}>>} resolves with the result array
+     */
+    evalArray(arr: AstNode[]): any;
+    /**
+     * 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.
+     * @param {{}} map A map of expression names to expression trees to be
+     *      evaluated
+     * @returns {Promise<{}>} resolves with the result map.
+     */
+    evalMap(map: Record<string, AstNode>): any;
+    /**
+     * 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): any;
+    /**
+     * 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): any;
+}
+export default Evaluator;

package/dist/evaluator/Evaluator.js

@@ -0,0 +1,153 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const handlers = __importStar(require("./handlers.js"));
+/**
+ * The Evaluator takes a Jexl expression tree as generated by the
+ * {@link Parser} and calculates its value within a given context. The
+ * collection of transforms, context, and a relative context to be used as the
+ * root for relative identifiers, are all specific to an Evaluator instance.
+ * When any of these things change, a new instance is required.  However, a
+ * single instance can be used to simultaneously evaluate many different
+ * expressions, and does not have to be reinstantiated for each.
+ * @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.
+ * @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 {
+    constructor(grammar, context, relativeContext, promise = Promise) {
+        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.
+     */
+    eval(ast) {
+        return this.Promise.resolve().then(() => {
+            return handlers[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.
+     * @param {Array<string>} arr An array of expression strings to be evaluated
+     * @returns {Promise<Array<{}>>} resolves with the result array
+     */
+    evalArray(arr) {
+        return this.Promise.all(arr.map((elem) => 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.
+     * @param {{}} map A map of expression names to expression trees to be
+     *      evaluated
+     * @returns {Promise<{}>} resolves with the result map.
+     */
+    evalMap(map) {
+        const entries = Object.entries(map);
+        const promises = entries.map(([_, ast]) => this.eval(ast));
+        return this.Promise.all(promises).then((vals) => 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, expr) {
+        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) => 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, expr) {
+        return this.eval(expr).then((res) => {
+            if (typeof res === 'boolean') {
+                return res ? subject : undefined;
+            }
+            return subject?.[res];
+        });
+    }
+}
+exports.default = Evaluator;
+//# sourceMappingURL=Evaluator.js.map