@jbrowse/jexl 2.3.1

package/dist/parser/Parser.d.ts

@@ -0,0 +1,112 @@
+import type Lexer from '../Lexer.ts';
+import type { AstNode, Token } from '../types.ts';
+interface Grammar {
+    elements: Record<string, any>;
+}
+/**
+ * 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.
+ */
+declare class Parser {
+    _grammar: Grammar;
+    _lexer: Lexer;
+    _state: string;
+    _tree: AstNode | null;
+    _exprStr: string;
+    _relative: boolean;
+    _stopMap: Record<string, any>;
+    _cursor?: AstNode | null;
+    _subParser?: Parser;
+    _parentStop?: boolean;
+    _nextIdentEncapsulate?: boolean;
+    _nextIdentRelative?: boolean;
+    _curObjKey?: string;
+    _sequenceExpressions?: AstNode[];
+    constructor(grammar: Grammar, lexer: Lexer, prefix?: string, stopMap?: Record<string, any>);
+    /**
+     * 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: Token): any;
+    /**
+     * 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: Token[]): void;
+    /**
+     * 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(): any;
+    /**
+     * Indicates whether the expression tree contains a relative path identifier.
+     * @returns {boolean} true if a relative identifier exists false otherwise.
+     */
+    isRelative(): boolean;
+    /**
+     * Ends a subexpression by completing the subParser and passing its result
+     * to the subHandler configured in the current state.
+     * @private
+     */
+    _endSubExpression(): void;
+    /**
+     * 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: AstNode): void;
+    /**
+     * 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: AstNode): void;
+    /**
+     * 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: AstNode, parent: AstNode): void;
+    /**
+     * 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?: string): void;
+}
+export default Parser;

package/dist/parser/Parser.js

@@ -0,0 +1,233 @@
+"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"));
+const states_ts_1 = require("./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_ts_1.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_ts_1.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_ts_1.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_ts_1.states[this._state].endStates;
+        if (!endStates) {
+            this._parentStop = true;
+            endStates = this._stopMap;
+        }
+        this._subParser = new Parser(this._grammar, this._lexer, exprStr, endStates);
+    }
+}
+exports.default = Parser;
+//# sourceMappingURL=Parser.js.map

package/dist/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/dist/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;