xmlui 0.4.0

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

@@ -0,0 +1,498 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = isPromise;
+exports.getCustomOperations = getCustomOperations;
+exports.evalLiteral = evalLiteral;
+exports.getIdentifierScope = getIdentifierScope;
+exports.evalIdentifier = evalIdentifier;
+exports.evalMemberAccessCore = evalMemberAccessCore;
+exports.evalCalculatedMemberAccessCore = evalCalculatedMemberAccessCore;
+exports.evalUnaryCore = evalUnaryCore;
+exports.evalBinaryCore = evalBinaryCore;
+exports.evalAssignmentCore = evalAssignmentCore;
+exports.evalPreOrPostCore = evalPreOrPostCore;
+exports.evalArrow = evalArrow;
+exports.obtainClosures = obtainClosures;
+const custom_operations_registry_1 = require("./custom-operations-registry");
+const custom_ui_data_1 = require("./custom-ui-data");
+const eval_tree_async_1 = require("./eval-tree-async");
+const ICustomOperations_1 = require("./ICustomOperations");
+// --- Type guard to check for a Promise
+function isPromise(obj) {
+    return obj && typeof obj.then === "function";
+}
+// --- Gets the optional custom operation for the specified operation type
+function getCustomOperations(opType, firstOperand, secondOperand) {
+    // --- The first operand must be a useful value or object
+    if (firstOperand === null || firstOperand === undefined)
+        return null;
+    // --- Is the first operand a custom UI type?
+    if (!(0, custom_ui_data_1.isCustomUiData)(firstOperand))
+        return null;
+    // --- Has the custom type registered a custom calculator object?
+    const calculator = custom_operations_registry_1.customOperationsRegistry.getOperationsObjectByKey(firstOperand._custom_data_type_);
+    if (!calculator)
+        return null;
+    // --- The calculator defines the requested operation?
+    let exists = false;
+    switch (opType) {
+        case ICustomOperations_1.CustomOperationType.MemberAccess:
+            exists = !!calculator.memberAccess;
+            break;
+        case ICustomOperations_1.CustomOperationType.CalculatedMemberAccess:
+            exists = !!calculator.calculatedMemberAccess;
+            break;
+        case ICustomOperations_1.CustomOperationType.UnaryPlus:
+            exists = !!calculator.unaryPlus;
+            break;
+        case ICustomOperations_1.CustomOperationType.UnaryMinus:
+            exists = !!calculator.unaryMinus;
+            break;
+        case ICustomOperations_1.CustomOperationType.LogicalNot:
+            exists = !!calculator.logicalNot;
+            break;
+        case ICustomOperations_1.CustomOperationType.BitwiseNot:
+            exists = !!calculator.bitwiseNot;
+            break;
+        case ICustomOperations_1.CustomOperationType.Multiply:
+            exists = !!calculator.multiply;
+            break;
+        case ICustomOperations_1.CustomOperationType.Divide:
+            exists = !!calculator.divide;
+            break;
+        case ICustomOperations_1.CustomOperationType.Remainder:
+            exists = !!calculator.remainder;
+            break;
+        case ICustomOperations_1.CustomOperationType.Add:
+            exists = !!calculator.add;
+            break;
+        case ICustomOperations_1.CustomOperationType.Subtract:
+            exists = !!calculator.subtract;
+            break;
+        case ICustomOperations_1.CustomOperationType.SignedRightShift:
+            exists = !!calculator.signedRightShift;
+            break;
+        case ICustomOperations_1.CustomOperationType.UnsignedRightShift:
+            exists = !!calculator.unsignedRightShift;
+            break;
+        case ICustomOperations_1.CustomOperationType.LeftShift:
+            exists = !!calculator.leftShift;
+            break;
+        case ICustomOperations_1.CustomOperationType.LessThan:
+            exists = !!calculator.lessThan;
+            break;
+        case ICustomOperations_1.CustomOperationType.LessThanOrEqual:
+            exists = !!calculator.lessThanOrEqual;
+            break;
+        case ICustomOperations_1.CustomOperationType.GreaterThan:
+            exists = !!calculator.greaterThan;
+            break;
+        case ICustomOperations_1.CustomOperationType.GreaterThanOrEqual:
+            exists = !!calculator.greaterThanOrEqual;
+            break;
+        case ICustomOperations_1.CustomOperationType.Equal:
+            exists = !!calculator.equal;
+            break;
+        case ICustomOperations_1.CustomOperationType.StrictEqual:
+            exists = !!calculator.strictEqual;
+            break;
+        case ICustomOperations_1.CustomOperationType.NotEqual:
+            exists = !!calculator.notEqual;
+            break;
+        case ICustomOperations_1.CustomOperationType.StrictNotEqual:
+            exists = !!calculator.strictNotEqual;
+            break;
+        case ICustomOperations_1.CustomOperationType.BitwiseAnd:
+            exists = !!calculator.bitwiseAnd;
+            break;
+        case ICustomOperations_1.CustomOperationType.BitwiseXor:
+            exists = !!calculator.bitwiseXor;
+            break;
+        case ICustomOperations_1.CustomOperationType.BitwiseOr:
+            exists = !!calculator.bitwiseOr;
+            break;
+        case ICustomOperations_1.CustomOperationType.LogicalAnd:
+            exists = !!calculator.logicalAnd;
+            break;
+        case ICustomOperations_1.CustomOperationType.LogicalOr:
+            exists = !!calculator.logicalOr;
+            break;
+        case ICustomOperations_1.CustomOperationType.NullCoalesce:
+            exists = !!calculator.nullCoalesce;
+            break;
+    }
+    // --- The calculator object must support the specified operation
+    if (!exists)
+        return null;
+    // --- Does the operation support the provided second operand?
+    return secondOperand !== undefined
+        ? calculator.supportSecondOperand(opType, secondOperand)
+            ? calculator
+            : null
+        : calculator;
+}
+// --- Evaluates a literal value (sync & async context)
+function evalLiteral(thisStack, expr) {
+    thisStack.push(expr.value);
+    return expr.value;
+}
+function getIdentifierScope(expr, evalContext, thread) {
+    var _a, _b, _c;
+    let type;
+    let scope;
+    // --- Search for primary value scope
+    if (expr.isGlobal) {
+        // --- Use the global scope only
+        scope = globalThis;
+        type = "global";
+    }
+    else {
+        // --- Iterate trough threads from the current to the parent
+        let currentThread = thread !== null && thread !== void 0 ? thread : evalContext.mainThread;
+        while (currentThread && !scope) {
+            if (currentThread.blocks) {
+                // --- Search the block-scopes
+                for (let idx = currentThread.blocks.length - 1; idx >= 0; idx--) {
+                    const blockContext = (_a = currentThread.blocks[idx]) === null || _a === void 0 ? void 0 : _a.vars;
+                    if (blockContext && expr.name in blockContext) {
+                        scope = blockContext;
+                        type = "block";
+                        break;
+                    }
+                }
+            }
+            // --- We may have already found the ID
+            if (scope)
+                break;
+            if (currentThread.closures) {
+                // --- Search block-scopes of the closure list
+                for (let idx = currentThread.closures.length - 1; idx >= 0; idx--) {
+                    const blockContext = (_b = currentThread.closures[idx]) === null || _b === void 0 ? void 0 : _b.vars;
+                    if (blockContext && expr.name in blockContext) {
+                        scope = blockContext;
+                        type = "block";
+                        break;
+                    }
+                }
+            }
+            // --- We may have already found the ID
+            if (scope)
+                break;
+            // --- Check the parent thread
+            currentThread = currentThread.parent;
+        }
+    }
+    // --- If no identifier found so far, check the local context, the app context, and finally, the global context
+    if (!scope) {
+        if (evalContext.localContext && expr.name in evalContext.localContext) {
+            // --- Object in localContext
+            scope = evalContext.localContext;
+            type = "localContext";
+        }
+        else if (((_c = evalContext.appContext) === null || _c === void 0 ? void 0 : _c[expr.name]) !== undefined) {
+            // --- Object in appContext
+            scope = evalContext.appContext;
+            type = "app";
+        }
+        else {
+            // --- Finally, check the global context
+            scope = globalThis;
+            type = "global";
+        }
+    }
+    // --- Done
+    return { type, scope: scope };
+}
+// --- Evaluates an identifier (sync & async context)
+function evalIdentifier(thisStack, expr, evalContext, thread) {
+    const idScope = getIdentifierScope(expr, evalContext, thread);
+    const valueScope = idScope.scope;
+    let valueIndex = expr.name;
+    let idObj;
+    // --- Get the variable value
+    expr.valueScope = valueScope;
+    expr.valueIndex = valueIndex;
+    idObj = valueScope[valueIndex];
+    // --- Done
+    expr.value = idObj;
+    thisStack.push(idObj);
+    return idObj;
+}
+// --- Evaluates a member access expression (sync & async context)
+function evalMemberAccessCore(parentObj, thisStack, expr, evalContext) {
+    var _a;
+    // --- 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.
+    expr.valueScope = parentObj;
+    expr.valueIndex = expr.member;
+    const memberObj = expr.isOptional || ((_a = evalContext.options) === null || _a === void 0 ? void 0 : _a.defaultToOptionalMemberAccess)
+        ? parentObj === null || parentObj === void 0 ? void 0 : parentObj[expr.member]
+        : parentObj[expr.member];
+    thisStack.push(memberObj);
+    // --- Done.
+    return memberObj;
+}
+// --- Evaluates a calculated member access expression (sync & async context)
+function evalCalculatedMemberAccessCore(parentObj, memberObj, thisStack, expr, evalContext) {
+    var _a;
+    // --- 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.
+    expr.valueScope = parentObj;
+    expr.valueIndex = memberObj;
+    const calcMemberObj = ((_a = evalContext.options) === null || _a === void 0 ? void 0 : _a.defaultToOptionalMemberAccess)
+        ? parentObj === null || parentObj === void 0 ? void 0 : parentObj[memberObj]
+        : parentObj[memberObj];
+    thisStack.push(calcMemberObj);
+    // --- Done.
+    return calcMemberObj;
+}
+// --- Evaluates a unary expression (sync & async context)
+function evalUnaryCore(expr, operand, thisStack, customOp) {
+    let unaryObj;
+    switch (expr.operator) {
+        case "typeof":
+            unaryObj = typeof operand;
+            break;
+        case "delete":
+            if (expr.operand.valueScope && expr.operand.valueIndex) {
+                return delete expr.operand.valueScope[expr.operand.valueIndex];
+            }
+            return false;
+        case "+":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.UnaryPlus, operand);
+            unaryObj = customOp ? customOp.unaryPlus(operand) : operand;
+            break;
+        case "-":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.UnaryMinus, operand);
+            unaryObj = customOp ? customOp.unaryPlus(operand) : -operand;
+            break;
+        case "!":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.LogicalNot, operand);
+            unaryObj = customOp ? customOp.unaryPlus(operand) : !operand;
+            break;
+        case "~":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.BitwiseNot, operand);
+            unaryObj = customOp ? customOp.unaryPlus(operand) : ~operand;
+            break;
+        default:
+            throw new Error(`Unknown unary operator: ${expr.operator}`);
+    }
+    thisStack.push(unaryObj);
+    return unaryObj;
+}
+// --- Evaluates a binary operation (sync & async context)
+function evalBinaryCore(l, r, thisStack, customOp, opSymbol) {
+    let binaryObj;
+    switch (opSymbol) {
+        case "**":
+            binaryObj = Math.pow(l, r);
+            break;
+        case "*":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.Multiply, l, r);
+            binaryObj = customOp ? customOp.multiply(l, r) : l * r;
+            break;
+        case "/":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.Divide, l, r);
+            binaryObj = customOp ? customOp.divide(l, r) : l / r;
+            break;
+        case "%":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.Remainder, l, r);
+            binaryObj = customOp ? customOp.remainder(l, r) : l % r;
+            break;
+        case "+":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.Add, l, r);
+            binaryObj = customOp ? customOp.add(l, r) : l + r;
+            break;
+        case "-":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.Subtract, l, r);
+            binaryObj = customOp ? customOp.subtract(l, r) : l - r;
+            break;
+        case ">>":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.SignedRightShift, l, r);
+            binaryObj = customOp ? customOp.signedRightShift(l, r) : l >> r;
+            break;
+        case ">>>":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.UnsignedRightShift, l, r);
+            binaryObj = customOp ? customOp.unsignedRightShift(l, r) : l >>> r;
+            break;
+        case "<<":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.LeftShift, l, r);
+            binaryObj = customOp ? customOp.leftShift(l, r) : l << r;
+            break;
+        case "<":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.LessThan, l, r);
+            binaryObj = customOp ? customOp.lessThan(l, r) : l < r;
+            break;
+        case "<=":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.LessThanOrEqual, l, r);
+            binaryObj = customOp ? customOp.lessThanOrEqual(l, r) : l <= r;
+            break;
+        case ">":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.GreaterThan, l, r);
+            binaryObj = customOp ? customOp.greaterThan(l, r) : l > r;
+            break;
+        case ">=":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.GreaterThanOrEqual, l, r);
+            binaryObj = customOp ? customOp.greaterThanOrEqual(l, r) : l >= r;
+            break;
+        case "in":
+            binaryObj = l in r;
+            break;
+        case "==":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.Equal, l, r);
+            // eslint-disable-next-line eqeqeq
+            binaryObj = customOp ? customOp.equal(l, r) : l == r;
+            break;
+        case "!=":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.NotEqual, l, r);
+            // eslint-disable-next-line eqeqeq
+            binaryObj = customOp ? customOp.notEqual(l, r) : l != r;
+            break;
+        case "===":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.StrictEqual, l, r);
+            binaryObj = customOp ? customOp.strictEqual(l, r) : l === r;
+            break;
+        case "!==":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.StrictNotEqual, l, r);
+            binaryObj = customOp ? customOp.strictNotEqual(l, r) : l !== r;
+            break;
+        case "&":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.BitwiseAnd, l, r);
+            binaryObj = customOp ? customOp.bitwiseAnd(l, r) : l & r;
+            break;
+        case "^":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.BitwiseXor, l, r);
+            binaryObj = customOp ? customOp.bitwiseXor(l, r) : l ^ r;
+            break;
+        case "|":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.BitwiseOr, l, r);
+            binaryObj = customOp ? customOp.bitwiseOr(l, r) : l | r;
+            break;
+        case "&&":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.LogicalAnd, l, r);
+            binaryObj = customOp ? customOp.logicalAnd(l, r) : l && r;
+            break;
+        case "||":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.LogicalOr, l, r);
+            binaryObj = customOp ? customOp.logicalOr(l, r) : l || r;
+            break;
+        case "??":
+            customOp = getCustomOperations(ICustomOperations_1.CustomOperationType.NullCoalesce, l, r);
+            binaryObj = customOp ? customOp.nullCoalesce(l, r) : l !== null && l !== void 0 ? l : r;
+            break;
+        default:
+            throw new Error(`Unknown binary operator: ${opSymbol}`);
+    }
+    thisStack.push(binaryObj);
+    return binaryObj;
+}
+// --- Evaluates an assignment operation (sync & async context)
+function evalAssignmentCore(leftValue, newValue, thisStack, expr, thread) {
+    var _a, _b;
+    if (!leftValue.valueScope || leftValue.valueIndex === undefined || leftValue.valueIndex === null) {
+        throw new Error(`Evaluation of ${expr.operator} requires a left-hand value., valueScope: ${leftValue.valueScope}, valueIndex: ${leftValue.valueIndex}`);
+    }
+    const leftScope = leftValue.valueScope;
+    const leftIndex = leftValue.valueIndex;
+    if (typeof leftScope !== "object" || leftScope === null) {
+        throw new Error(`Unknown left-hand value ${leftValue === null || leftValue === void 0 ? void 0 : leftValue.source}, ${expr.source}`);
+    }
+    // --- Check for const value
+    if (expr.leftValue.type === "IdE") {
+        if ((0, eval_tree_async_1.isConstVar)(expr.leftValue.name, thread)) {
+            throw new Error("A const variable cannot be modified");
+        }
+    }
+    if (leftScope === globalThis && !(leftIndex in leftScope)) {
+        throw new Error(`Left value variable (${leftIndex}) not found in the scope.`);
+    }
+    thisStack.pop();
+    switch (expr.operator) {
+        case "=":
+            leftScope[leftIndex] = newValue;
+            break;
+        case "+=":
+            leftScope[leftIndex] += newValue;
+            break;
+        case "-=":
+            leftScope[leftIndex] -= newValue;
+            break;
+        case "**=":
+            (_a = leftScope)[_b = leftIndex] = Math.pow(_a[_b], newValue);
+            break;
+        case "*=":
+            leftScope[leftIndex] *= newValue;
+            break;
+        case "/=":
+            leftScope[leftIndex] /= newValue;
+            break;
+        case "%=":
+            leftScope[leftIndex] %= newValue;
+            break;
+        case "<<=":
+            leftScope[leftIndex] <<= newValue;
+            break;
+        case ">>=":
+            leftScope[leftIndex] >>= newValue;
+            break;
+        case ">>>=":
+            leftScope[leftIndex] >>>= newValue;
+            break;
+        case "&=":
+            leftScope[leftIndex] &= newValue;
+            break;
+        case "^=":
+            leftScope[leftIndex] ^= newValue;
+            break;
+        case "|=":
+            leftScope[leftIndex] |= newValue;
+            break;
+        case "&&=":
+            leftScope[leftIndex] && (leftScope[leftIndex] = newValue);
+            break;
+        case "||=":
+            leftScope[leftIndex] || (leftScope[leftIndex] = newValue);
+            break;
+        case "??=":
+            leftScope[leftIndex] += newValue;
+            break;
+    }
+    const value = leftScope[leftIndex];
+    thisStack.push(value);
+    return value;
+}
+// --- Evaluates a prefix/postfix operator (sync & async context)
+function evalPreOrPostCore(operand, thisStack, expr, evalContext, thread) {
+    if (!operand.valueScope || operand.valueIndex === undefined) {
+        throw new Error(`Evaluation of ${expr.operator} requires a left-hand value.`);
+    }
+    // --- Check for const value
+    if (expr.operand.type === "IdE") {
+        if ((0, eval_tree_async_1.isConstVar)(expr.operand.name, thread)) {
+            // --- We cannot modify a const value
+            throw new Error("A const variable cannot be modified");
+        }
+    }
+    const value = expr.operator === "++"
+        ? expr.type === "PrefE"
+            ? ++operand.valueScope[operand.valueIndex]
+            : operand.valueScope[operand.valueIndex]++
+        : expr.type === "PrefE"
+            ? --operand.valueScope[operand.valueIndex]
+            : operand.valueScope[operand.valueIndex]--;
+    thisStack.push(value);
+    return value;
+}
+// --- Evaluates an arrow expression (lazy, sync & async context)
+function evalArrow(thisStack, expr, thread) {
+    const lazyArrow = Object.assign(Object.assign({}, expr), { _ARROW_EXPR_: true, closureContext: obtainClosures(thread) });
+    thisStack.push(lazyArrow);
+    return lazyArrow;
+}
+function obtainClosures(thread) {
+    var _a, _b;
+    const closures = (_b = (_a = thread.blocks) === null || _a === void 0 ? void 0 : _a.slice(0)) !== null && _b !== void 0 ? _b : [];
+    return thread.parent ? [...obtainClosures(thread.parent), ...closures] : closures;
+}