@jbrowse/jexl 2.3.1

package/esm/parser/Parser.js

@@ -0,0 +1,198 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+import * as handlers from "./handlers.js";
+import { states } from "./states.js";
+/**
+ * The Parser is a state machine that converts tokens from the {@link Lexer}
+ * into an Abstract Syntax Tree (AST), capable of being evaluated in any
+ * context by the {@link Evaluator}.  The Parser expects that all tokens
+ * provided to it are legal and typed properly according to the grammar, but
+ * accepts that the tokens may still be in an invalid order or in some other
+ * unparsable configuration that requires it to throw an Error.
+ * @param {{}} grammar The grammar object to use to parse Jexl strings
+ * @param {string} [prefix] A string prefix to prepend to the expression string
+ *      for error messaging purposes.  This is useful for when a new Parser is
+ *      instantiated to parse an subexpression, as the parent Parser's
+ *      expression string thus far can be passed for a more user-friendly
+ *      error message.
+ * @param {{}} [stopMap] A mapping of token types to any truthy value. When the
+ *      token type is encountered, the parser will return the mapped value
+ *      instead of boolean false.
+ */
+class Parser {
+    constructor(grammar, lexer, prefix, stopMap) {
+        this._grammar = grammar;
+        this._lexer = lexer;
+        this._state = 'expectOperand';
+        this._tree = null;
+        this._exprStr = prefix || '';
+        this._relative = false;
+        this._stopMap = stopMap || {};
+    }
+    /**
+     * Processes a new token into the AST and manages the transitions of the state
+     * machine.
+     * @param {{type: <string>}} token A token object, as provided by the
+     *      {@link Lexer#tokenize} function.
+     * @throws {Error} if a token is added when the Parser has been marked as
+     *      complete by {@link #complete}, or if an unexpected token type is added.
+     * @returns {boolean|*} the stopState value if this parser encountered a token
+     *      in the stopState mapb false if tokens can continue.
+     */
+    addToken(token) {
+        if (this._state === 'complete') {
+            throw new Error('Cannot add a new token to a completed Parser');
+        }
+        const state = states[this._state];
+        const startExpr = this._exprStr;
+        this._exprStr += token.raw;
+        if (state.subHandler) {
+            if (!this._subParser) {
+                this._startSubExpression(startExpr);
+            }
+            const stopState = this._subParser.addToken(token);
+            if (stopState) {
+                this._endSubExpression();
+                if (this._parentStop) {
+                    return stopState;
+                }
+                this._state = stopState;
+            }
+        }
+        else if (state.tokenTypes?.[token.type]) {
+            const typeOpts = state.tokenTypes[token.type];
+            let handleFunc = handlers[token.type];
+            if (typeOpts.handler) {
+                handleFunc = typeOpts.handler;
+            }
+            if (handleFunc) {
+                handleFunc.call(this, token);
+            }
+            if (typeOpts.toState) {
+                this._state = typeOpts.toState;
+            }
+        }
+        else if (this._stopMap[token.type]) {
+            return this._stopMap[token.type];
+        }
+        else {
+            throw new Error(`Token ${token.raw} (${token.type}) unexpected in expression: ${this._exprStr}`);
+        }
+        return false;
+    }
+    /**
+     * Processes an array of tokens iteratively through the {@link #addToken}
+     * function.
+     * @param {Array<{type: <string>}>} tokens An array of tokens, as provided by
+     *      the {@link Lexer#tokenize} function.
+     */
+    addTokens(tokens) {
+        tokens.forEach((token) => this.addToken(token));
+    }
+    /**
+     * Marks this Parser instance as completed and retrieves the full AST.
+     * @returns {{}|null} a full expression tree, ready for evaluation by the
+     *      {@link Evaluator#eval} function, or null if no tokens were passed to
+     *      the parser before complete was called
+     * @throws {Error} if the parser is not in a state where it's legal to end
+     *      the expression, indicating that the expression is incomplete
+     */
+    complete() {
+        if (this._cursor && !states[this._state].completable) {
+            throw new Error(`Unexpected end of expression: ${this._exprStr}`);
+        }
+        if (this._subParser) {
+            this._endSubExpression();
+        }
+        if (this._sequenceExpressions) {
+            this._sequenceExpressions.push(this._tree);
+            const sequence = {
+                type: 'SequenceExpression',
+                expressions: this._sequenceExpressions
+            };
+            this._state = 'complete';
+            return sequence;
+        }
+        this._state = 'complete';
+        return this._cursor ? this._tree : null;
+    }
+    /**
+     * Indicates whether the expression tree contains a relative path identifier.
+     * @returns {boolean} true if a relative identifier exists false otherwise.
+     */
+    isRelative() {
+        return this._relative;
+    }
+    /**
+     * Ends a subexpression by completing the subParser and passing its result
+     * to the subHandler configured in the current state.
+     * @private
+     */
+    _endSubExpression() {
+        states[this._state].subHandler.call(this, this._subParser.complete());
+        this._subParser = undefined;
+    }
+    /**
+     * Places a new tree node at the current position of the cursor (to the 'right'
+     * property) and then advances the cursor to the new node. This function also
+     * handles setting the parent of the new node.
+     * @param {{type: <string>}} node A node to be added to the AST
+     * @private
+     */
+    _placeAtCursor(node) {
+        if (!this._cursor) {
+            this._tree = node;
+        }
+        else {
+            ;
+            this._cursor.right = node;
+            this._setParent(node, this._cursor);
+        }
+        this._cursor = node;
+    }
+    /**
+     * Places a tree node before the current position of the cursor, replacing
+     * the node that the cursor currently points to. This should only be called in
+     * cases where the cursor is known to exist, and the provided node already
+     * contains a pointer to what's at the cursor currently.
+     * @param {{type: <string>}} node A node to be added to the AST
+     * @private
+     */
+    _placeBeforeCursor(node) {
+        this._cursor = this._cursor?._parent;
+        this._placeAtCursor(node);
+    }
+    /**
+     * Sets the parent of a node by creating a non-enumerable _parent property
+     * that points to the supplied parent argument.
+     * @param {{type: <string>}} node A node of the AST on which to set a new
+     *      parent
+     * @param {{type: <string>}} parent An existing node of the AST to serve as the
+     *      parent of the new node
+     * @private
+     */
+    _setParent(node, parent) {
+        Object.defineProperty(node, '_parent', {
+            value: parent,
+            writable: true
+        });
+    }
+    /**
+     * Prepares the Parser to accept a subexpression by (re)instantiating the
+     * subParser.
+     * @param {string} [exprStr] The expression string to prefix to the new Parser
+     * @private
+     */
+    _startSubExpression(exprStr) {
+        let endStates = states[this._state].endStates;
+        if (!endStates) {
+            this._parentStop = true;
+            endStates = this._stopMap;
+        }
+        this._subParser = new Parser(this._grammar, this._lexer, exprStr, endStates);
+    }
+}
+export default Parser;
+//# sourceMappingURL=Parser.js.map

package/esm/parser/Parser.js.map

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

package/esm/parser/handlers.d.ts

@@ -0,0 +1,112 @@
+import type { AstNode, Token } from '../types.ts';
+import type Parser from './Parser.ts';
+/**
+ * Handles a subexpression that's used to define a transform argument's value.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function argVal(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles new array literals by adding them as a new node in the AST,
+ * initialized with an empty array.
+ */
+export declare function arrayStart(this: Parser): void;
+/**
+ * Handles a subexpression representing an element of an array literal.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function arrayVal(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles tokens of type 'binaryOp', indicating an operation that has two
+ * inputs: a left side and a right side.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function binaryOp(this: Parser, token: Token): void;
+/**
+ * Handles successive nodes in an identifier chain.  More specifically, it
+ * sets values that determine how the following identifier gets placed in the
+ * AST.
+ */
+export declare function dot(this: Parser): void;
+/**
+ * Handles a subexpression used for filtering an array returned by an
+ * identifier chain.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function filter(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles identifier tokens when used to indicate the name of a function to
+ * be called.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function functionCall(this: Parser): void;
+/**
+ * Handles identifier tokens by adding them as a new node in the AST.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function identifier(this: Parser, token: Token): void;
+/**
+ * Handles literal values, such as strings, booleans, and numerics, by adding
+ * them as a new node in the AST.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function literal(this: Parser, token: Token): void;
+/**
+ * Handles template string tokens by parsing their interpolation expressions
+ * and creating a TemplateLiteral AST node.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function templateString(this: Parser, token: Token): void;
+/**
+ * Queues a new object literal key to be written once a value is collected.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function objKey(this: Parser, token: Token): void;
+/**
+ * Handles new object literals by adding them as a new node in the AST,
+ * initialized with an empty object.
+ */
+export declare function objStart(this: Parser): void;
+/**
+ * Handles an object value by adding its AST to the queued key on the object
+ * literal node currently at the cursor.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function objVal(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles traditional subexpressions, delineated with the groupStart and
+ * groupEnd elements.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function subExpression(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles a completed alternate subexpression of a ternary operator.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function ternaryEnd(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles a completed consequent subexpression of a ternary operator.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export declare function ternaryMid(this: Parser, ast: AstNode | null): void;
+/**
+ * Handles the start of a new ternary expression by encapsulating the entire
+ * AST in a ConditionalExpression node, and using the existing tree as the
+ * test element.
+ */
+export declare function ternaryStart(this: Parser): void;
+/**
+ * Handles identifier tokens when used to indicate the name of a transform to
+ * be applied.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function transform(this: Parser, token: Token): void;
+/**
+ * Handles token of type 'unaryOp', indicating that the operation has only
+ * one input: a right side.
+ * @param {{type: <string>}} token A token object
+ */
+export declare function unaryOp(this: Parser, token: Token): void;
+/**
+ * Handles semicolon separator between expressions
+ */
+export declare function semicolon(this: Parser): void;

package/esm/parser/handlers.js

@@ -0,0 +1,280 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+/**
+ * Handles a subexpression that's used to define a transform argument's value.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function argVal(ast) {
+    if (ast) {
+        ;
+        this._cursor.args.push(ast);
+    }
+}
+/**
+ * Handles new array literals by adding them as a new node in the AST,
+ * initialized with an empty array.
+ */
+export function arrayStart() {
+    this._placeAtCursor({
+        type: 'ArrayLiteral',
+        value: []
+    });
+}
+/**
+ * Handles a subexpression representing an element of an array literal.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function arrayVal(ast) {
+    if (ast) {
+        ;
+        this._cursor.value.push(ast);
+    }
+}
+/**
+ * Handles tokens of type 'binaryOp', indicating an operation that has two
+ * inputs: a left side and a right side.
+ * @param {{type: <string>}} token A token object
+ */
+export function binaryOp(token) {
+    if (token.value === '=') {
+        if (this._cursor?.type !== 'Identifier') {
+            throw new Error('Left side of assignment must be a variable name');
+        }
+        const node = {
+            type: 'AssignmentExpression',
+            operator: '=',
+            left: this._cursor
+        };
+        this._cursor = this._cursor._parent;
+        this._placeAtCursor(node);
+        return;
+    }
+    const precedence = this._grammar.elements[token.value].precedence || 0;
+    let parent = this._cursor?._parent;
+    while (parent &&
+        parent.operator &&
+        this._grammar.elements[parent.operator].precedence >= precedence) {
+        this._cursor = parent;
+        parent = parent._parent;
+    }
+    const node = {
+        type: 'BinaryExpression',
+        operator: token.value,
+        left: this._cursor
+    };
+    this._setParent(this._cursor, node);
+    this._cursor = parent;
+    this._placeAtCursor(node);
+}
+/**
+ * Handles successive nodes in an identifier chain.  More specifically, it
+ * sets values that determine how the following identifier gets placed in the
+ * AST.
+ */
+export function dot() {
+    const isBinaryExprWithRight = (node) => node.type === 'BinaryExpression' && node.right;
+    this._nextIdentEncapsulate =
+        this._cursor &&
+            this._cursor.type !== 'UnaryExpression' &&
+            (this._cursor.type !== 'BinaryExpression' ||
+                isBinaryExprWithRight(this._cursor));
+    this._nextIdentRelative = !this._cursor || !this._nextIdentEncapsulate;
+    if (this._nextIdentRelative) {
+        this._relative = true;
+    }
+}
+/**
+ * Handles a subexpression used for filtering an array returned by an
+ * identifier chain.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function filter(ast) {
+    this._placeBeforeCursor({
+        type: 'FilterExpression',
+        expr: ast,
+        relative: this._subParser.isRelative(),
+        subject: this._cursor
+    });
+}
+/**
+ * Handles identifier tokens when used to indicate the name of a function to
+ * be called.
+ * @param {{type: <string>}} token A token object
+ */
+export function functionCall() {
+    this._placeBeforeCursor({
+        type: 'FunctionCall',
+        name: this._cursor.value,
+        args: [],
+        pool: 'functions'
+    });
+}
+/**
+ * Handles identifier tokens by adding them as a new node in the AST.
+ * @param {{type: <string>}} token A token object
+ */
+export function identifier(token) {
+    const node = {
+        type: 'Identifier',
+        value: token.value
+    };
+    if (this._nextIdentEncapsulate) {
+        node.from = this._cursor;
+        this._placeBeforeCursor(node);
+        this._nextIdentEncapsulate = false;
+    }
+    else {
+        if (this._nextIdentRelative) {
+            node.relative = true;
+            this._nextIdentRelative = false;
+        }
+        this._placeAtCursor(node);
+    }
+}
+/**
+ * Handles literal values, such as strings, booleans, and numerics, by adding
+ * them as a new node in the AST.
+ * @param {{type: <string>}} token A token object
+ */
+export function literal(token) {
+    this._placeAtCursor({
+        type: 'Literal',
+        value: token.value
+    });
+}
+/**
+ * Handles template string tokens by parsing their interpolation expressions
+ * and creating a TemplateLiteral AST node.
+ * @param {{type: <string>}} token A token object
+ */
+export function templateString(token) {
+    const parts = [];
+    for (const part of token.value) {
+        if (part.type === 'static') {
+            parts.push({
+                type: 'static',
+                value: this._lexer._unescapeTemplateString(part.value)
+            });
+        }
+        else {
+            const subTokens = this._lexer.tokenize(part.value);
+            const subParser = new this.constructor(this._grammar, this._lexer);
+            subParser.addTokens(subTokens);
+            const subAst = subParser.complete();
+            if (!subAst) {
+                throw new Error('Empty interpolation in template string');
+            }
+            parts.push({
+                type: 'expression',
+                value: subAst
+            });
+        }
+    }
+    this._placeAtCursor({
+        type: 'TemplateLiteral',
+        parts: parts
+    });
+}
+/**
+ * Queues a new object literal key to be written once a value is collected.
+ * @param {{type: <string>}} token A token object
+ */
+export function objKey(token) {
+    this._curObjKey = token.value;
+}
+/**
+ * Handles new object literals by adding them as a new node in the AST,
+ * initialized with an empty object.
+ */
+export function objStart() {
+    this._placeAtCursor({
+        type: 'ObjectLiteral',
+        value: {}
+    });
+}
+/**
+ * Handles an object value by adding its AST to the queued key on the object
+ * literal node currently at the cursor.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function objVal(ast) {
+    ;
+    this._cursor.value[this._curObjKey] = ast;
+}
+/**
+ * Handles traditional subexpressions, delineated with the groupStart and
+ * groupEnd elements.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function subExpression(ast) {
+    this._placeAtCursor(ast);
+}
+/**
+ * Handles a completed alternate subexpression of a ternary operator.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function ternaryEnd(ast) {
+    ;
+    this._cursor.alternate = ast;
+}
+/**
+ * Handles a completed consequent subexpression of a ternary operator.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+export function ternaryMid(ast) {
+    ;
+    this._cursor.consequent = ast;
+}
+/**
+ * Handles the start of a new ternary expression by encapsulating the entire
+ * AST in a ConditionalExpression node, and using the existing tree as the
+ * test element.
+ */
+export function ternaryStart() {
+    this._tree = {
+        type: 'ConditionalExpression',
+        test: this._tree
+    };
+    this._cursor = this._tree;
+}
+/**
+ * Handles identifier tokens when used to indicate the name of a transform to
+ * be applied.
+ * @param {{type: <string>}} token A token object
+ */
+export function transform(token) {
+    this._placeBeforeCursor({
+        type: 'FunctionCall',
+        name: token.value,
+        args: [this._cursor],
+        pool: 'transforms'
+    });
+}
+/**
+ * Handles token of type 'unaryOp', indicating that the operation has only
+ * one input: a right side.
+ * @param {{type: <string>}} token A token object
+ */
+export function unaryOp(token) {
+    this._placeAtCursor({
+        type: 'UnaryExpression',
+        operator: token.value
+    });
+}
+/**
+ * Handles semicolon separator between expressions
+ */
+export function semicolon() {
+    if (!this._sequenceExpressions) {
+        this._sequenceExpressions = [this._tree];
+    }
+    else {
+        this._sequenceExpressions.push(this._tree);
+    }
+    this._tree = null;
+    this._cursor = null;
+    this._state = 'expectOperand';
+}
+//# sourceMappingURL=handlers.js.map

package/esm/parser/handlers.js.map

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

package/esm/parser/states.d.ts

@@ -0,0 +1,47 @@
+import type { AstNode } from '../types.ts';
+import type Parser from './Parser.ts';
+interface TokenTypeOptions {
+    toState?: string;
+    handler?: (this: Parser, ...args: any[]) => void;
+}
+interface StateDefinition {
+    tokenTypes?: Record<string, TokenTypeOptions>;
+    subHandler?: (this: Parser, ast: AstNode | null) => void;
+    endStates?: Record<string, string>;
+    completable?: boolean;
+}
+type States = Record<string, StateDefinition>;
+/**
+ * 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 declare const states: States;
+export {};