@pawel-up/jexl/lib/Jexl.js

Javascript Expression Language: Powerful context-based expression parser and evaluator

import Expression from './Expression.js';
import { getGrammar, } from './grammar.js';
export class Jexl {
    grammar;
    constructor() {
        this.expr = this.expr.bind(this);
        this.grammar = getGrammar();
    }
    addBinaryOp(operator, precedence, fn, manualEval) {
        const element = {
            type: 'binaryOp',
            precedence: precedence,
        };
        if (manualEval) {
            element.evalOnDemand = fn;
        }
        else {
            element.eval = fn;
        }
        this._addGrammarElement(operator, element);
    }
    addFunction(name, fn) {
        this.grammar.functions[name] = fn;
    }
    addFunctions(map) {
        for (const key in map) {
            if (Object.prototype.hasOwnProperty.call(map, key)) {
                const fn = map[key];
                if (fn) {
                    this.grammar.functions[key] = fn;
                }
            }
        }
    }
    addUnaryOp(operator, fn) {
        const element = {
            type: 'unaryOp',
            weight: Infinity,
            eval: fn,
        };
        this._addGrammarElement(operator, element);
    }
    addTransform(name, fn) {
        this.grammar.transforms[name] = fn;
    }
    addTransforms(map) {
        for (const key in map) {
            if (Object.prototype.hasOwnProperty.call(map, key)) {
                const fn = map[key];
                if (fn) {
                    this.grammar.transforms[key] = fn;
                }
            }
        }
    }
    compile(expression) {
        const exprObj = this.createExpression(expression);
        return exprObj.compile();
    }
    createExpression(expression) {
        return new Expression(this.grammar, expression);
    }
    getFunction(name) {
        const fn = this.grammar.functions[name];
        if (!fn) {
            throw new Error(`Function '${name}' is not defined`);
        }
        return fn;
    }
    getTransform(name) {
        const fn = this.grammar.transforms[name];
        if (!fn) {
            throw new Error(`Transform '${name}' is not defined`);
        }
        return fn;
    }
    eval(expression, context = {}) {
        const exprObj = this.createExpression(expression);
        return exprObj.eval(context);
    }
    evalAsString(expression, context = {}) {
        const exprObj = this.createExpression(expression);
        return exprObj.evalAsString(context);
    }
    evalAsNumber(expression, context = {}) {
        const exprObj = this.createExpression(expression);
        return exprObj.evalAsNumber(context);
    }
    evalAsBoolean(expression, context = {}) {
        const exprObj = this.createExpression(expression);
        return exprObj.evalAsBoolean(context);
    }
    evalAsArray(expression, context = {}) {
        const exprObj = this.createExpression(expression);
        return exprObj.evalAsArray(context);
    }
    evalAsEnum(expression, context = {}, allowedValues) {
        const exprObj = this.createExpression(expression);
        return exprObj.evalAsEnum(context, allowedValues);
    }
    evalWithDefault(expression, context = {}, defaultValue) {
        const exprObj = this.createExpression(expression);
        return exprObj.evalWithDefault(context, defaultValue);
    }
    expr(strings, ...args) {
        const exprStr = strings.reduce((acc, str, idx) => {
            const arg = idx < args.length ? args[idx] : '';
            acc += str + arg;
            return acc;
        }, '');
        return this.createExpression(exprStr);
    }
    removeOp(operator) {
        if (Object.prototype.hasOwnProperty.call(this.grammar.elements, operator) &&
            (this.grammar.elements[operator].type === 'binaryOp' || this.grammar.elements[operator].type === 'unaryOp')) {
            delete this.grammar.elements[operator];
        }
    }
    _addGrammarElement(str, obj) {
        this.grammar.elements[str] = obj;
    }
}
//# sourceMappingURL=Jexl.js.map