@player-ui/player/types/expressions/evaluator.d.ts

import { SyncWaterfallHook, SyncBailHook } from "tapable-ts";
import type { ExpressionNode, BinaryOperator, UnaryOperator, ExpressionType, ExpressionContext, ExpressionHandler } from "./types";
export interface HookOptions extends ExpressionContext {
    /** Given an expression node  */
    resolveNode: (node: ExpressionNode) => any;
    /** Enabling this flag skips calling the onError hook, and just throws errors back to the caller.
     * The caller is responsible for handling the error.
     */
    throwErrors?: boolean;
    /** Whether expressions should be parsed strictly or not */
    strict?: boolean;
    /** Whether the expression should be evaluated asynchronously */
    async?: boolean;
}
export type ExpressionEvaluatorOptions = Omit<HookOptions, "resolveNode" | "evaluate">;
export type ExpressionEvaluatorFunction = (exp: ExpressionType, options?: ExpressionEvaluatorOptions) => any;
/**
 * The expression evaluator is responsible for parsing and executing anything in the custom expression language
 * */
export declare class ExpressionEvaluator {
    private readonly vars;
    readonly hooks: {
        resolve: SyncWaterfallHook<[any, ExpressionNode, HookOptions]>;
        resolveOptions: SyncWaterfallHook<[HookOptions]>;
        beforeEvaluate: SyncWaterfallHook<[ExpressionType, HookOptions]>;
        onError: SyncBailHook<[Error], true>;
    };
    private readonly expressionsCache;
    private readonly defaultHookOptions;
    readonly operators: {
        binary: Map<string, BinaryOperator>;
        unary: Map<string, UnaryOperator>;
        expressions: Map<string, ExpressionHandler<any, any>>;
    };
    reset(): void;
    constructor(defaultOptions: ExpressionEvaluatorOptions);
    evaluate(expr: ExpressionType, options?: ExpressionEvaluatorOptions): any;
    /**
     * Evaluate functions in an async context
     * @experimental These Player APIs are in active development and may change. Use with caution
     */
    evaluateAsync(expr: ExpressionType, options?: ExpressionEvaluatorOptions): Promise<any>;
    addExpressionFunction<T extends readonly unknown[], R>(name: string, handler: ExpressionHandler<T, R>): void;
    addBinaryOperator(operator: string, handler: BinaryOperator): void;
    addUnaryOperator(operator: string, handler: UnaryOperator): void;
    setExpressionVariable(name: string, value: unknown): void;
    getExpressionVariable(name: string): unknown;
    private _execAST;
    private _execString;
    private _resolveNode;
}
//# sourceMappingURL=evaluator.d.ts.map