xmlui 0.8.6 → 0.9.1

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

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.evalBindingExpression = evalBindingExpression;
 exports.evalBinding = evalBinding;
 exports.executeArrowExpressionSync = executeArrowExpressionSync;
-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 ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
+const Parser_1 = require("../../parsers/scripting-exp/Parser");
 const bannedFunctions_1 = require("./bannedFunctions");
-const syncProxy_1 = require("./syncProxy");
 const eval_tree_common_1 = require("./eval-tree-common");
+const process_statement_common_1 = require("./process-statement-common");
+const process_statement_sync_1 = require("./process-statement-sync");
 /**
  * Evaluates the specified binding expression tree and retrieves the evaluated value
  * @param source Binding tree expression
@@ -54,13 +54,13 @@ function evalBinding(expr, evalContext, thread) {
  */
 function executeArrowExpressionSync(expr, evalContext, thread, ...args) {
     // --- Just an extra safety check
-    if (expr.type !== "ArrowE") {
+    if (expr.type !== ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
         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);
+    const nativeFunction = createArrowFunction(evaluator, expr, evalContext);
     // --- 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
@@ -82,50 +82,47 @@ function evalBindingExpressionTree(thisStack, expr, evalContext, thread) {
         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":
+        case ScriptingSourceTreeExp_1.T_TEMPLATE_LITERAL_EXPRESSION:
             return evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread);
-        case "LitE":
-            return (0, eval_tree_common_1.evalLiteral)(thisStack, expr);
-        case "IdE":
+        case ScriptingSourceTreeExp_1.T_LITERAL:
+            return (0, eval_tree_common_1.evalLiteral)(thisStack, expr, thread);
+        case ScriptingSourceTreeExp_1.T_IDENTIFIER:
             return (0, eval_tree_common_1.evalIdentifier)(thisStack, expr, evalContext, thread);
-        case "MembE":
+        case ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION:
             return evalMemberAccess(evaluator, thisStack, expr, evalContext, thread);
-        case "CMembE":
+        case ScriptingSourceTreeExp_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
             return evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread);
-        case "SeqE":
+        case ScriptingSourceTreeExp_1.T_SEQUENCE_EXPRESSION:
             return evalSequence(evaluator, thisStack, expr, evalContext, thread);
-        case "ALitE":
+        case ScriptingSourceTreeExp_1.T_ARRAY_LITERAL:
             return evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread);
-        case "OLitE":
+        case ScriptingSourceTreeExp_1.T_OBJECT_LITERAL:
             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":
+        case ScriptingSourceTreeExp_1.T_UNARY_EXPRESSION:
+            return evalUnary(evaluator, thisStack, expr, evalContext, thread);
+        case ScriptingSourceTreeExp_1.T_BINARY_EXPRESSION:
+            return evalBinary(evaluator, thisStack, expr, evalContext, thread);
+        case ScriptingSourceTreeExp_1.T_CONDITIONAL_EXPRESSION:
             return evalConditional(evaluator, thisStack, expr, evalContext, thread);
-        case "AsgnE":
+        case ScriptingSourceTreeExp_1.T_ASSIGNMENT_EXPRESSION:
             return evalAssignment(evaluator, thisStack, expr, evalContext, thread);
-        case "PrefE":
-        case "PostfE":
+        case ScriptingSourceTreeExp_1.T_PREFIX_OP_EXPRESSION:
+        case ScriptingSourceTreeExp_1.T_POSTFIX_OP_EXPRESSION:
             return evalPreOrPost(evaluator, thisStack, expr, evalContext, thread);
-        case "InvokeE":
+        case ScriptingSourceTreeExp_1.T_FUNCTION_INVOCATION_EXPRESSION:
             // --- 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":
+        case ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION:
             // --- Special sync handling
             return (0, eval_tree_common_1.evalArrow)(thisStack, expr, thread);
-        case "SpreadE":
+        case ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION:
             throw new Error("Cannot use spread expression (...) with the current intermediate value.");
         default:
             throw new Error(`Unknown expression tree node: ${expr.type}`);
@@ -140,56 +137,59 @@ function evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread) {
     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);
+    evaluator(thisStack, expr.obj, 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);
+    return (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr, evalContext, thread);
+}
+function evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+    evaluator(thisStack, expr.obj, evalContext, thread);
+    evaluator(thisStack, expr.member, evalContext, thread);
     thisStack.pop();
-    return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(parentObj, memberObj, thisStack, expr, evalContext);
+    return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(thisStack, expr, evalContext, thread);
 }
 function evalSequence(evaluator, thisStack, expr, evalContext, thread) {
-    if (!expr.expressions || expr.expressions.length === 0) {
+    if (!expr.exprs || expr.exprs.length === 0) {
         throw new Error(`Missing expression sequence`);
     }
-    const result = expr.expressions.map((e) => {
-        const exprValue = evaluator(thisStack, e, evalContext, thread);
+    const result = expr.exprs.map((e) => {
+        const value = evaluator(thisStack, e, evalContext, thread);
+        (0, eval_tree_common_1.setExprValue)(e, { value }, thread);
         thisStack.pop();
-        return exprValue;
+        return value;
     });
     const lastObj = result[result.length - 1];
     thisStack.push(lastObj);
     return lastObj;
 }
 function evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread) {
-    const arrayValue = [];
+    const value = [];
     for (const item of expr.items) {
-        if (item.type === "SpreadE") {
-            const spreadArray = evaluator(thisStack, item.operand, evalContext, thread);
+        if (item.type === ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION) {
+            const spreadArray = evaluator(thisStack, item.expr, evalContext, thread);
             thisStack.pop();
             if (!Array.isArray(spreadArray)) {
                 throw new Error("Spread operator within an array literal expects an array operand.");
             }
-            arrayValue.push(...spreadArray);
+            value.push(...spreadArray);
         }
         else {
-            arrayValue.push(evaluator(thisStack, item, evalContext, thread));
+            value.push(evaluator(thisStack, item, evalContext, thread));
             thisStack.pop();
-            thisStack.push(arrayValue);
+            thisStack.push(value);
         }
     }
-    return arrayValue;
+    // --- Done.
+    (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
+    return value;
 }
 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);
+            const spreadItems = evaluator(thisStack, prop.expr, evalContext, thread);
             thisStack.pop();
             if (Array.isArray(spreadItems)) {
                 // --- Spread of an array
@@ -208,10 +208,10 @@ function evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread) {
         // --- We're using key/[value] pairs
         let key;
         switch (prop[0].type) {
-            case "LitE":
+            case ScriptingSourceTreeExp_1.T_LITERAL:
                 key = prop[0].value;
                 break;
-            case "IdE":
+            case ScriptingSourceTreeExp_1.T_IDENTIFIER:
                 key = prop[0].name;
                 break;
             default:
@@ -222,63 +222,86 @@ function evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread) {
         objectHash[key] = evaluator(thisStack, prop[1], evalContext, thread);
         thisStack.pop();
     }
+    // --- Done.
+    (0, eval_tree_common_1.setExprValue)(expr, { value: objectHash }, thread);
     thisStack.push(objectHash);
     return objectHash;
 }
-function evalUnary(evaluator, thisStack, customOp, expr, evalContext, thread) {
-    const operand = evaluator(thisStack, expr.operand, evalContext, thread);
+function evalUnary(evaluator, thisStack, expr, evalContext, thread) {
+    evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
-    return (0, eval_tree_common_1.evalUnaryCore)(expr, operand, thisStack, customOp);
+    return (0, eval_tree_common_1.evalUnaryCore)(expr, thisStack, evalContext, thread);
 }
-function evalBinary(evaluator, thisStack, customOp, expr, evalContext, thread) {
-    const l = evaluator(thisStack, expr.left, evalContext, thread);
+function evalBinary(evaluator, thisStack, expr, evalContext, thread) {
+    var _a;
+    evaluator(thisStack, expr.left, evalContext, thread);
     thisStack.pop();
-    if (expr.operator === "&&" && !l) {
-        thisStack.push(l);
+    const l = (_a = (0, eval_tree_common_1.getExprValue)(expr.left, thread)) === null || _a === void 0 ? void 0 : _a.value;
+    if (expr.op === "&&" && !l) {
+        (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
         return l;
     }
-    if (expr.operator === "||" && l) {
-        thisStack.push(l);
+    if (expr.op === "||" && l) {
+        (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
         return l;
     }
-    const r = evaluator(thisStack, expr.right, evalContext, thread);
+    evaluator(thisStack, expr.right, evalContext, thread);
     thisStack.pop();
-    return (0, eval_tree_common_1.evalBinaryCore)(l, r, thisStack, customOp, expr.operator);
+    return (0, eval_tree_common_1.evalBinaryCore)(expr, thisStack, evalContext, thread);
 }
 function evalConditional(evaluator, thisStack, expr, evalContext, thread) {
-    const condition = evaluator(thisStack, expr.condition, evalContext, thread);
+    const condition = evaluator(thisStack, expr.cond, evalContext, thread);
     thisStack.pop();
-    return evaluator(thisStack, condition ? expr.consequent : expr.alternate, evalContext, thread);
+    const value = evaluator(thisStack, condition ? expr.thenE : expr.elseE, evalContext, thread);
+    (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
+    return value;
 }
 function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
     const leftValue = expr.leftValue;
+    const rootScope = (0, eval_tree_common_1.getRootIdScope)(leftValue, evalContext, thread);
+    const updatesState = rootScope && rootScope.type !== "block";
+    if (updatesState && evalContext.onWillUpdate) {
+        evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
+    }
     evaluator(thisStack, leftValue, evalContext, thread);
     thisStack.pop();
-    const newValue = evaluator(thisStack, expr.operand, evalContext, thread);
+    evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
-    return (0, eval_tree_common_1.evalAssignmentCore)(leftValue, newValue, thisStack, expr, thread);
+    const value = (0, eval_tree_common_1.evalAssignmentCore)(thisStack, expr, evalContext, thread);
+    if (updatesState && evalContext.onDidUpdate) {
+        evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
+    }
+    return value;
 }
 function evalPreOrPost(evaluator, thisStack, expr, evalContext, thread) {
-    const operand = expr.operand;
-    evaluator(thisStack, operand, evalContext, thread);
+    const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.expr, evalContext, thread);
+    const updatesState = rootScope && rootScope.type !== "block";
+    if (updatesState && evalContext.onWillUpdate) {
+        evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
+    }
+    evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
-    return (0, eval_tree_common_1.evalPreOrPostCore)(operand, thisStack, expr, evalContext, thread);
+    const value = (0, eval_tree_common_1.evalPreOrPostCore)(thisStack, expr, evalContext, thread);
+    if (updatesState && evalContext.onDidUpdate) {
+        evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
+    }
+    return value;
 }
 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 (expr.obj.type === ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION && expr.obj.obj.type === ScriptingSourceTreeExp_1.T_IDENTIFIER) {
+        const hostObject = evaluator(thisStack, expr.obj.obj, evalContext, thread);
+        functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr.obj, evalContext, thread);
         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);
+        functionObj = evaluator(thisStack, expr.obj, evalContext, thread);
     }
     thisStack.pop();
     // --- Keep function arguments here, we pass it to the function later
@@ -286,34 +309,34 @@ function evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread)
     // --- 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);
+        functionObj = createArrowFunction(evaluator, functionObj, evalContext);
     }
-    else if (expr.object.type === "ArrowE") {
+    else if (expr.obj.type === ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
         // --- 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 }))));
+        functionArgs.push(expr.obj.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 (arg.type === ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION) {
+                const funcArg = evaluator([], arg.expr, 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);
+                if (arg.type === ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
+                    const funcArg = createArrowFunction(evaluator, arg, evalContext);
                     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 wrappedFuncArg = createArrowFunction(evaluator, funcArg, evalContext);
                         const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
                         functionArgs.push(wrappedFunc);
                     }
@@ -342,17 +365,23 @@ function evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread)
     }
     // --- 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 rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.obj, evalContext, thread);
+    const updatesState = rootScope && rootScope.type !== "block";
+    if (updatesState && evalContext.onWillUpdate) {
+        evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
+    }
     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);
+    if (updatesState && evalContext.onDidUpdate) {
+        evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
+    }
+    (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
     thisStack.push(value);
     return value;
 }
-function createArrowFunction(evaluator, expr) {
+function createArrowFunction(evaluator, expr, evalContext) {
     // --- Use this function, it evaluates the arrow function
     return (...args) => {
         var _a, _b;
@@ -388,32 +417,31 @@ function createArrowFunction(evaluator, expr) {
             const argSpec = argSpecs[i];
             let decl;
             switch (argSpec.type) {
-                case "IdE": {
+                case ScriptingSourceTreeExp_1.T_IDENTIFIER: {
                     decl = {
-                        type: "VarD",
+                        type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
                         id: argSpec.name,
                     };
                     break;
                 }
-                case "Destr": {
+                case ScriptingSourceTreeExp_1.T_DESTRUCTURE: {
                     decl = {
-                        type: "VarD",
+                        type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
                         id: argSpec.id,
-                        arrayDestruct: argSpec.arrayDestruct,
-                        objectDestruct: argSpec.objectDestruct,
+                        aDestr: argSpec.aDestr,
+                        oDestr: argSpec.oDestr,
                     };
                     break;
                 }
-                case "SpreadE": {
+                case ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION: {
                     restFound = true;
                     decl = {
-                        type: "VarD",
-                        id: argSpec.operand.name,
+                        type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
+                        id: argSpec.expr.name,
                     };
                     break;
                 }
                 default:
-                    console.log(argSpec);
                     throw new Error("Unexpected arrow argument specification");
             }
             if (decl) {
@@ -445,21 +473,22 @@ function createArrowFunction(evaluator, expr) {
         let returnValue;
         let statements;
         switch (expr.statement.type) {
-            case "EmptyS":
+            case ScriptingSourceTreeExp_1.T_EMPTY_STATEMENT:
                 statements = [];
                 break;
-            case "ExprS":
+            case ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT:
                 // --- Create a new thread for the call
                 statements = [
                     {
-                        type: "RetS",
-                        expression: expr.statement.expression,
+                        type: ScriptingSourceTreeExp_1.T_RETURN_STATEMENT,
+                        nodeId: (0, Parser_1.createXmlUiTreeNodeId)(),
+                        expr: expr.statement.expr,
                     },
                 ];
                 break;
-            case "BlockS":
+            case ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT:
                 // --- Create a new thread for the call
-                statements = expr.statement.statements;
+                statements = expr.statement.stmts;
                 break;
             default:
                 throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);