xmlui 0.7.14 → 0.7.16

package/dist/scripts/src/components-core/script-runner/eval-tree-sync.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalBindingExpression = evalBindingExpression;
+exports.evalBinding = evalBinding;
+exports.executeArrowExpressionSync = executeArrowExpressionSync;
+const eval_tree_common_1 = require("./eval-tree-common");
+const Parser_1 = require("../../parsers/scripting/Parser");
+const process_statement_common_1 = require("./process-statement-common");
+const process_statement_sync_1 = require("./process-statement-sync");
+const bannedFunctions_1 = require("./bannedFunctions");
+const syncProxy_1 = require("./syncProxy");
+/**
+ * Evaluates the specified binding expression tree and retrieves the evaluated value
+ * @param source Binding tree expression
+ * @param evalContext Evaluation context
+ * @param thread The logical thread to use for evaluation
+ * This code uses the JavaScript semantics and errors when evaluating the code.
+ */
+function evalBindingExpression(source, evalContext, thread) {
+    // --- Use the main thread by default
+    thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
+    // --- Parse the source code
+    const wParser = new Parser_1.Parser(source);
+    const tree = wParser.parseExpr();
+    if (tree === null) {
+        // --- This should happen only when an expression is empty
+        return undefined;
+    }
+    // --- Check for expression termination
+    if (!wParser.isEof) {
+        throw new Error("Expression is not terminated properly");
+    }
+    // --- Ok, valid source, evaluate
+    return evalBinding(tree, evalContext, thread);
+}
+/**
+ * Evaluates a binding represented by the specified expression
+ * @param expr Expression to evaluate
+ * @param evalContext Evaluation context to use
+ * @param thread The logical thread to use for evaluation
+ */
+function evalBinding(expr, evalContext, thread) {
+    const thisStack = [];
+    (0, process_statement_common_1.ensureMainThread)(evalContext);
+    thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
+    return evalBindingExpressionTree(thisStack, expr, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread);
+}
+/**
+ * Executes the specified arrow function
+ * @param expr Arrow function expression to run
+ * @param evalContext Evaluation context to use
+ * @param thread The logical thread to use for evaluation
+ * @param args Arguments of the arrow function to execute
+ */
+function executeArrowExpressionSync(expr, evalContext, thread, ...args) {
+    // --- Just an extra safety check
+    if (expr.type !== "ArrowE") {
+        throw new Error("executeArrowExpression expects an 'ArrowExpression' object.");
+    }
+    // --- This is the evaluator that an arrow expression uses internally
+    const evaluator = evalBindingExpressionTree;
+    // --- Compiles the Arrow function to a JavaScript function
+    const nativeFunction = createArrowFunction(evaluator, expr);
+    // --- Run the compiled arrow function. Note, we have two prefix arguments:
+    // --- #1: The names of arrow function arguments
+    // --- #2: The evaluation context the arrow function runs in
+    // --- #others: The real arguments of the arrow function
+    return nativeFunction(expr.args, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread, ...args);
+}
+/**
+ * Evaluates the specified binding expression tree and retrieves the evaluated value
+ * @param expr Binding tree expression
+ * @param thisStack Stack of "this" object to use with function calls
+ * @param evalContext Evaluation context
+ * @param thread The logical thread to use for evaluation
+ * This code uses the JavaScript semantics and errors when evaluating the code.
+ * We use `thisStack` to keep track of the partial results of the evaluation tree so that we can set
+ * the real `this` context when invoking a function.
+ */
+function evalBindingExpressionTree(thisStack, expr, evalContext, thread) {
+    if (!evalContext.options) {
+        evalContext.options = { defaultToOptionalMemberAccess: true };
+    }
+    // --- Prepare evaluation
+    let customOp = null;
+    const evaluator = evalBindingExpressionTree;
+    // --- Reset the expression scope
+    expr.valueScope = expr.valueIndex = undefined;
+    // --- Process the expression according to its type
+    switch (expr.type) {
+        case "TempLitE":
+            return evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread);
+        case "LitE":
+            return (0, eval_tree_common_1.evalLiteral)(thisStack, expr);
+        case "IdE":
+            return (0, eval_tree_common_1.evalIdentifier)(thisStack, expr, evalContext, thread);
+        case "MembE":
+            return evalMemberAccess(evaluator, thisStack, expr, evalContext, thread);
+        case "CMembE":
+            return evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread);
+        case "SeqE":
+            return evalSequence(evaluator, thisStack, expr, evalContext, thread);
+        case "ALitE":
+            return evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread);
+        case "OLitE":
+            return evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread);
+        case "UnaryE":
+            return evalUnary(evaluator, thisStack, customOp, expr, evalContext, thread);
+        case "BinaryE":
+            return evalBinary(evaluator, thisStack, customOp, expr, evalContext, thread);
+        case "CondE":
+            return evalConditional(evaluator, thisStack, expr, evalContext, thread);
+        case "AsgnE":
+            return evalAssignment(evaluator, thisStack, expr, evalContext, thread);
+        case "PrefE":
+        case "PostfE":
+            return evalPreOrPost(evaluator, thisStack, expr, evalContext, thread);
+        case "InvokeE":
+            // --- Special sync handling
+            const funcResult = evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread);
+            if ((0, eval_tree_common_1.isPromise)(funcResult)) {
+                throw new Error("Promises (async function calls) are not allowed in binding expressions.");
+            }
+            return funcResult;
+        case "ArrowE":
+            // --- Special sync handling
+            return (0, eval_tree_common_1.evalArrow)(thisStack, expr, thread);
+        case "SpreadE":
+            throw new Error("Cannot use spread expression (...) with the current intermediate value.");
+        default:
+            throw new Error(`Unknown expression tree node: ${expr.type}`);
+    }
+}
+function evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread) {
+    const segmentValues = expr.segments.map((s) => {
+        const evaledValue = evaluator(thisStack, s, evalContext, thread);
+        thisStack.pop();
+        return evaledValue;
+    });
+    return (0, eval_tree_common_1.evalTemplateLiteralCore)(segmentValues);
+}
+function evalMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+    const parentObj = evaluator(thisStack, expr.object, evalContext, thread);
+    return (0, eval_tree_common_1.evalMemberAccessCore)(parentObj, thisStack, expr, evalContext);
+}
+function evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+    const parentObj = evaluator(thisStack, expr.object, evalContext, thread);
+    // --- At this point we definitely keep the parent object on `thisStack`, as it will be the context object
+    // --- of a FunctionInvocationExpression, if that follows the MemberAccess. Other operations would call
+    // --- `thisStack.pop()` to remove the result from the previous `evalBindingExpressionTree` call.
+    const memberObj = evaluator(thisStack, expr.member, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(parentObj, memberObj, thisStack, expr, evalContext);
+}
+function evalSequence(evaluator, thisStack, expr, evalContext, thread) {
+    if (!expr.expressions || expr.expressions.length === 0) {
+        throw new Error(`Missing expression sequence`);
+    }
+    const result = expr.expressions.map((e) => {
+        const exprValue = evaluator(thisStack, e, evalContext, thread);
+        thisStack.pop();
+        return exprValue;
+    });
+    const lastObj = result[result.length - 1];
+    thisStack.push(lastObj);
+    return lastObj;
+}
+function evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread) {
+    const arrayValue = [];
+    for (const item of expr.items) {
+        if (item.type === "SpreadE") {
+            const spreadArray = evaluator(thisStack, item.operand, evalContext, thread);
+            thisStack.pop();
+            if (!Array.isArray(spreadArray)) {
+                throw new Error("Spread operator within an array literal expects an array operand.");
+            }
+            arrayValue.push(...spreadArray);
+        }
+        else {
+            arrayValue.push(evaluator(thisStack, item, evalContext, thread));
+            thisStack.pop();
+            thisStack.push(arrayValue);
+        }
+    }
+    return arrayValue;
+}
+function evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread) {
+    const objectHash = {};
+    for (const prop of expr.props) {
+        if (!Array.isArray(prop)) {
+            // --- We're using a spread expression
+            const spreadItems = evaluator(thisStack, prop.operand, evalContext, thread);
+            thisStack.pop();
+            if (Array.isArray(spreadItems)) {
+                // --- Spread of an array
+                for (let i = 0; i < spreadItems.length; i++) {
+                    objectHash[i] = spreadItems[i];
+                }
+            }
+            else if (typeof spreadItems === "object") {
+                // --- Spread of a hash object
+                for (const [key, value] of Object.entries(spreadItems)) {
+                    objectHash[key] = value;
+                }
+            }
+            continue;
+        }
+        // --- We're using key/[value] pairs
+        let key;
+        switch (prop[0].type) {
+            case "LitE":
+                key = prop[0].value;
+                break;
+            case "IdE":
+                key = prop[0].name;
+                break;
+            default:
+                key = evaluator(thisStack, prop[0], evalContext, thread);
+                thisStack.pop();
+                break;
+        }
+        objectHash[key] = evaluator(thisStack, prop[1], evalContext, thread);
+        thisStack.pop();
+    }
+    thisStack.push(objectHash);
+    return objectHash;
+}
+function evalUnary(evaluator, thisStack, customOp, expr, evalContext, thread) {
+    const operand = evaluator(thisStack, expr.operand, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalUnaryCore)(expr, operand, thisStack, customOp);
+}
+function evalBinary(evaluator, thisStack, customOp, expr, evalContext, thread) {
+    const l = evaluator(thisStack, expr.left, evalContext, thread);
+    thisStack.pop();
+    if (expr.operator === "&&" && !l) {
+        thisStack.push(l);
+        return l;
+    }
+    if (expr.operator === "||" && l) {
+        thisStack.push(l);
+        return l;
+    }
+    const r = evaluator(thisStack, expr.right, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalBinaryCore)(l, r, thisStack, customOp, expr.operator);
+}
+function evalConditional(evaluator, thisStack, expr, evalContext, thread) {
+    const condition = evaluator(thisStack, expr.condition, evalContext, thread);
+    thisStack.pop();
+    return evaluator(thisStack, condition ? expr.consequent : expr.alternate, evalContext, thread);
+}
+function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
+    const leftValue = expr.leftValue;
+    evaluator(thisStack, leftValue, evalContext, thread);
+    thisStack.pop();
+    const newValue = evaluator(thisStack, expr.operand, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalAssignmentCore)(leftValue, newValue, thisStack, expr, thread);
+}
+function evalPreOrPost(evaluator, thisStack, expr, evalContext, thread) {
+    const operand = expr.operand;
+    evaluator(thisStack, operand, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalPreOrPostCore)(operand, thisStack, expr, evalContext, thread);
+}
+function evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread) {
+    var _a, _b, _c, _d;
+    let functionObj;
+    let implicitContextObject = null;
+    // --- Check for contexted object
+    if (expr.object.type === "MembE" && expr.object.object.type === "IdE") {
+        const hostObject = evaluator(thisStack, expr.object.object, evalContext, thread);
+        functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(hostObject, thisStack, expr.object, evalContext);
+        if (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT) {
+            implicitContextObject = hostObject;
+        }
+    }
+    else {
+        // --- Get the object on which to invoke the function
+        functionObj = evaluator(thisStack, expr.object, evalContext, thread);
+    }
+    thisStack.pop();
+    // --- Keep function arguments here, we pass it to the function later
+    const functionArgs = [];
+    // --- The functionObj may be an ArrowExpression. In this care we need to create the invokable arrow function
+    if (functionObj === null || functionObj === void 0 ? void 0 : functionObj._ARROW_EXPR_) {
+        functionArgs.push(functionObj.args, evalContext, thread, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+        functionObj = createArrowFunction(evaluator, functionObj);
+    }
+    else if (expr.object.type === "ArrowE") {
+        // --- We delay evaluating expression values. We pass the argument names as the first parameter, and then
+        // --- all parameter expressions
+        functionArgs.push(expr.object.args, evalContext, thread, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+    }
+    else {
+        // --- We evaluate the argument values to pass to a JavaScript function
+        for (let i = 0; i < expr.arguments.length; i++) {
+            const arg = expr.arguments[i];
+            if (arg.type === "SpreadE") {
+                const funcArg = evaluator([], arg.operand, evalContext, thread);
+                if (!Array.isArray(funcArg)) {
+                    throw new Error("Spread operator within a function invocation expects an array operand.");
+                }
+                functionArgs.push(...funcArg);
+            }
+            else {
+                if (arg.type === "ArrowE") {
+                    const funcArg = createArrowFunction(evaluator, arg);
+                    const wrappedFunc = (...args) => funcArg(arg.args, evalContext, thread, ...args);
+                    functionArgs.push(wrappedFunc);
+                }
+                else {
+                    const funcArg = evaluator([], arg, evalContext, thread);
+                    if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
+                        const wrappedFuncArg = createArrowFunction(evaluator, funcArg);
+                        const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
+                        functionArgs.push(wrappedFunc);
+                    }
+                    else {
+                        functionArgs.push(funcArg);
+                    }
+                }
+            }
+        }
+        // --- We can pass implicit arguments to JavaScript function
+        if (implicitContextObject) {
+            // --- Let's obtain the implicit context
+            if (evalContext.implicitContextGetter) {
+                const implicitContext = evalContext.implicitContextGetter(implicitContextObject);
+                functionArgs.unshift(implicitContext);
+            }
+            else {
+                throw new Error("Cannot use implicitContextGetter, it is undefined");
+            }
+        }
+    }
+    // --- Check if the function is banned from running
+    const bannedInfo = (0, bannedFunctions_1.isBannedFunction)(functionObj);
+    if (bannedInfo.banned) {
+        throw new Error(`Function ${(_b = (_a = bannedInfo.func) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unknown"} is not allowed to call. ${(_c = bannedInfo === null || bannedInfo === void 0 ? void 0 : bannedInfo.help) !== null && _c !== void 0 ? _c : ""}`);
+    }
+    // --- We use context for "this"
+    const currentContext = thisStack.length > 0 ? thisStack.pop() : evalContext.localContext;
+    // --- We need to use proxies for JavaScript functions (such as Array.prototype.sort) using
+    // --- in-place changes on DataSource values
+    functionObj = (0, syncProxy_1.getSyncProxy)(functionObj, functionArgs, currentContext);
+    // --- Now, invoke the function
+    const value = ((_d = evalContext.options) === null || _d === void 0 ? void 0 : _d.defaultToOptionalMemberAccess)
+        ? functionObj === null || functionObj === void 0 ? void 0 : functionObj.call(currentContext, ...functionArgs)
+        : functionObj.call(currentContext, ...functionArgs);
+    thisStack.push(value);
+    return value;
+}
+function createArrowFunction(evaluator, expr) {
+    // --- Use this function, it evaluates the arrow function
+    return (...args) => {
+        var _a, _b;
+        // --- Prepare the variables to pass
+        const runTimeEvalContext = args[1];
+        const runtimeThread = args[2];
+        // --- Create the thread that runs the arrow function
+        const workingThread = {
+            parent: runtimeThread,
+            childThreads: [],
+            blocks: [{ vars: {} }],
+            loops: [],
+            breakLabelValue: -1,
+            closures: expr.closureContext,
+        };
+        runtimeThread.childThreads.push(workingThread);
+        // --- Create a block for a named arrow function
+        if (expr.name) {
+            const functionBlock = { vars: {} };
+            (_a = workingThread.blocks) !== null && _a !== void 0 ? _a : (workingThread.blocks = []);
+            workingThread.blocks.push(functionBlock);
+            functionBlock.vars[expr.name] = expr;
+            functionBlock.constVars = new Set([expr.name]);
+        }
+        // --- Assign argument values to names
+        const arrowBlock = { vars: {} };
+        (_b = workingThread.blocks) !== null && _b !== void 0 ? _b : (workingThread.blocks = []);
+        workingThread.blocks.push(arrowBlock);
+        const argSpecs = args[0];
+        let restFound = false;
+        for (let i = 0; i < argSpecs.length; i++) {
+            // --- Turn argument specification into processable variable declarations
+            const argSpec = argSpecs[i];
+            let decl;
+            switch (argSpec.type) {
+                case "IdE": {
+                    decl = {
+                        type: "VarD",
+                        id: argSpec.name,
+                    };
+                    break;
+                }
+                case "Destr": {
+                    decl = {
+                        type: "VarD",
+                        id: argSpec.id,
+                        arrayDestruct: argSpec.arrayDestruct,
+                        objectDestruct: argSpec.objectDestruct,
+                    };
+                    break;
+                }
+                case "SpreadE": {
+                    restFound = true;
+                    decl = {
+                        type: "VarD",
+                        id: argSpec.operand.name,
+                    };
+                    break;
+                }
+                default:
+                    console.log(argSpec);
+                    throw new Error("Unexpected arrow argument specification");
+            }
+            if (decl) {
+                if (restFound) {
+                    // --- Get the rest of the arguments
+                    const restArgs = args.slice(i + 3);
+                    let argVals = [];
+                    for (const arg of restArgs) {
+                        if (arg === null || arg === void 0 ? void 0 : arg._EXPRESSION_) {
+                            argVals.push(evaluator([], arg, runTimeEvalContext, runtimeThread));
+                        }
+                        else {
+                            argVals.push(arg);
+                        }
+                    }
+                    (0, process_statement_sync_1.processDeclarations)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVals);
+                }
+                else {
+                    // --- Get the actual value to work with
+                    let argVal = args[i + 3];
+                    if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
+                        argVal = evaluator([], argVal, runTimeEvalContext, runtimeThread);
+                    }
+                    (0, process_statement_sync_1.processDeclarations)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
+                }
+            }
+        }
+        // --- Evaluate the arrow expression body
+        let returnValue;
+        let statements;
+        switch (expr.statement.type) {
+            case "EmptyS":
+                statements = [];
+                break;
+            case "ExprS":
+                // --- Create a new thread for the call
+                statements = [
+                    {
+                        type: "RetS",
+                        expression: expr.statement.expression,
+                    },
+                ];
+                break;
+            case "BlockS":
+                // --- Create a new thread for the call
+                statements = expr.statement.statements;
+                break;
+            default:
+                throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);
+        }
+        // --- Process the statement with a new processor
+        (0, process_statement_sync_1.processStatementQueue)(statements, runTimeEvalContext, workingThread);
+        // --- Return value is in a return value slot
+        returnValue = workingThread.returnValue;
+        // --- Remove the current working thread
+        const workingIndex = runtimeThread.childThreads.indexOf(workingThread);
+        if (workingIndex < 0) {
+            throw new Error("Cannot find thread to remove.");
+        }
+        runtimeThread.childThreads.splice(workingIndex, 1);
+        // --- Remove the function level block
+        workingThread.blocks.pop();
+        // --- Return the function value
+        return returnValue;
+    };
+}