xmlui 0.8.6 → 0.9.1

package/dist/scripts/src/components-core/script-runner/statement-queue.js

@@ -45,15 +45,16 @@ function mapToItem(statement) {
     return [
         {
             label: nextLabelValue++,
-            statement: Object.assign({}, statement)
-        }
+            statement: Object.assign({}, statement),
+        },
     ];
 }
 // --- Map a single statement into a queue item
-function mapStatementToQueueItem(statement) {
+function mapStatementToQueueItem(stmt) {
     return {
         label: nextLabelValue++,
-        statement: Object.assign({}, statement)
+        statement: stmt.statement,
+        execInfo: Object.assign({}, stmt.execInfo),
     };
 }
 // --- Map a list of statements into queue items

package/dist/scripts/src/components-core/script-runner/visitors.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectVariableDependencies = collectVariableDependencies;
 const lodash_es_1 = require("lodash-es");
 const eval_tree_common_1 = require("./eval-tree-common");
+const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
 const process_statement_common_1 = require("./process-statement-common");
 /**
  * Collects the name of local context variables the specified program depends on
@@ -25,108 +26,108 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
             program.forEach((stmt) => {
                 let stmtDeps = [];
                 switch (stmt.type) {
-                    case "BlockS":
+                    case ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT:
                         thread.blocks.push({ vars: {} });
-                        stmtDeps = collectDependencies(stmt.statements, stmt, "block");
+                        stmtDeps = collectDependencies(stmt.stmts, stmt, "block");
                         thread.blocks.pop();
                         break;
-                    case "ExprS":
-                        stmtDeps = collectDependencies(stmt.expression, stmt, "expression");
+                    case ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT:
+                        stmtDeps = collectDependencies(stmt.expr, stmt, "expression");
                         break;
-                    case "ArrowS":
+                    case ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT:
                         thread.blocks.push({ vars: {} });
-                        stmtDeps = collectDependencies(stmt.expression, stmt, "arrow");
+                        stmtDeps = collectDependencies(stmt.expr, stmt, "arrow");
                         thread.blocks.pop();
                         break;
-                    case "LetS":
-                    case "ConstS":
-                        processDeclarations((0, process_statement_common_1.innermostBlockScope)(thread), stmt.declarations);
-                        stmt.declarations.forEach((decl) => {
-                            if (decl.expression) {
-                                stmtDeps = stmtDeps.concat(collectDependencies(decl.expression, stmt, "letOrConst"));
+                    case ScriptingSourceTreeExp_1.T_LET_STATEMENT:
+                    case ScriptingSourceTreeExp_1.T_CONST_STATEMENT:
+                        processDeclarations((0, process_statement_common_1.innermostBlockScope)(thread), stmt.decls);
+                        stmt.decls.forEach((decl) => {
+                            if (decl.expr) {
+                                stmtDeps = stmtDeps.concat(collectDependencies(decl.expr, stmt, "letOrConst"));
                             }
                         });
                         break;
-                    case "IfS":
-                        stmtDeps = collectDependencies(stmt.condition, stmt, "if");
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.thenBranch], stmt, "if"));
-                        if (stmt.elseBranch) {
-                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.elseBranch], stmt, "if"));
+                    case ScriptingSourceTreeExp_1.T_IF_STATEMENT:
+                        stmtDeps = collectDependencies(stmt.cond, stmt, "if");
+                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.thenB], stmt, "if"));
+                        if (stmt.elseB) {
+                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.elseB], stmt, "if"));
                         }
                         break;
-                    case "RetS":
-                        if (stmt.expression) {
-                            stmtDeps = collectDependencies(stmt.expression, stmt, "return");
+                    case ScriptingSourceTreeExp_1.T_RETURN_STATEMENT:
+                        if (stmt.expr) {
+                            stmtDeps = collectDependencies(stmt.expr, stmt, "return");
                         }
                         break;
-                    case "WhileS":
-                        stmtDeps = collectDependencies(stmt.condition, stmt, "while");
+                    case ScriptingSourceTreeExp_1.T_WHILE_STATEMENT:
+                        stmtDeps = collectDependencies(stmt.cond, stmt, "while");
                         stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "while"));
                         break;
-                    case "DoWS":
-                        stmtDeps = collectDependencies(stmt.condition, stmt, "doWhile");
+                    case ScriptingSourceTreeExp_1.T_DO_WHILE_STATEMENT:
+                        stmtDeps = collectDependencies(stmt.cond, stmt, "doWhile");
                         stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "doWhile"));
                         break;
-                    case "ForS":
+                    case ScriptingSourceTreeExp_1.T_FOR_STATEMENT:
                         thread.blocks.push({ vars: {} });
                         if (stmt.init) {
                             stmtDeps.concat(collectDependencies([stmt.init], stmt, "for"));
                         }
-                        if (stmt.condition) {
-                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.condition, stmt, "for"));
+                        if (stmt.cond) {
+                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.cond, stmt, "for"));
                         }
-                        if (stmt.update) {
-                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.update, stmt, "for"));
+                        if (stmt.upd) {
+                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.upd, stmt, "for"));
                         }
                         stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "for"));
                         thread.blocks.pop();
                         break;
-                    case "ForInS":
+                    case ScriptingSourceTreeExp_1.T_FOR_IN_STATEMENT:
                         thread.blocks.push({ vars: {} });
-                        if (stmt.varBinding !== "none") {
+                        if (stmt.varB !== "none") {
                             const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                            block.vars[stmt.id] = true;
+                            block.vars[stmt.id.name] = true;
                         }
-                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expression, stmt, "forIn"));
+                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expr, stmt, "forIn"));
                         stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "forIn"));
                         thread.blocks.pop();
                         break;
-                    case "ForOfS":
+                    case ScriptingSourceTreeExp_1.T_FOR_OF_STATEMENT:
                         thread.blocks.push({ vars: {} });
-                        if (stmt.varBinding !== "none") {
+                        if (stmt.varB !== "none") {
                             const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                            block.vars[stmt.id] = true;
+                            block.vars[stmt.id.name] = true;
                         }
-                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expression, stmt, "forOf"));
+                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expr, stmt, "forOf"));
                         stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "forOf"));
                         thread.blocks.pop();
                         break;
-                    case "ThrowS":
-                        stmtDeps = collectDependencies(stmt.expression, stmt, "throw");
+                    case ScriptingSourceTreeExp_1.T_THROW_STATEMENT:
+                        stmtDeps = collectDependencies(stmt.expr, stmt, "throw");
                         break;
-                    case "TryS":
-                        stmtDeps = collectDependencies([stmt.tryBlock], stmt, "try");
-                        if (stmt.catchBlock) {
+                    case ScriptingSourceTreeExp_1.T_TRY_STATEMENT:
+                        stmtDeps = collectDependencies([stmt.tryB], stmt, "try");
+                        if (stmt.catchB) {
                             thread.blocks.push({ vars: {} });
-                            if (stmt.catchVariable) {
+                            if (stmt.catchV) {
                                 const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                                block.vars[stmt.catchVariable] = true;
+                                block.vars[stmt.catchV.name] = true;
                             }
-                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.catchBlock], stmt, "catchBlock"));
+                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.catchB], stmt, "catchBlock"));
                             thread.blocks.pop();
                         }
-                        if (stmt.finallyBlock) {
-                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.finallyBlock], stmt, "finallyBlock"));
+                        if (stmt.finallyB) {
+                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.finallyB], stmt, "finallyBlock"));
                         }
                         break;
-                    case "SwitchS":
-                        stmtDeps = collectDependencies(stmt.expression, stmt, "switch");
+                    case ScriptingSourceTreeExp_1.T_SWITCH_STATEMENT:
+                        stmtDeps = collectDependencies(stmt.expr, stmt, "switch");
                         stmt.cases.forEach((c) => {
-                            if (c.caseExpression) {
-                                stmtDeps = stmtDeps.concat(collectDependencies(c.caseExpression, stmt, "switch"));
+                            if (c.caseE) {
+                                stmtDeps = stmtDeps.concat(collectDependencies(c.caseE, stmt, "switch"));
                             }
-                            if (c.statements) {
-                                stmtDeps = stmtDeps.concat(collectDependencies(c.statements, stmt, "switch"));
+                            if (c.stmts) {
+                                stmtDeps = stmtDeps.concat(collectDependencies(c.stmts, stmt, "switch"));
                             }
                         });
                         break;
@@ -138,55 +139,59 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
         else {
             // --- Visit expression
             switch (program.type) {
-                case "IdE":
+                case ScriptingSourceTreeExp_1.T_IDENTIFIER:
                     // --- Any non-block-scoped variable is a dependency to return
                     const scope = (0, eval_tree_common_1.getIdentifierScope)(program, evalContext, thread);
                     return scope.type !== "block" ? [program.name] : [];
-                case "MembE":
+                case ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION:
                     // --- Check for a simple member-access chain. If it exist, add the member to the chain with the "." syntax
                     const memberChain = traverseMemberAccessChain(program);
-                    return memberChain ? [memberChain] : collectDependencies(program.object, program, "memberAccess");
-                case "CMembE":
+                    return memberChain
+                        ? [memberChain]
+                        : collectDependencies(program.obj, program, "memberAccess");
+                case ScriptingSourceTreeExp_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
                     // --- Check for a simple member-access chain. If it exist, add the member to the chain with the "[]" syntax
                     const calcMemberChain = traverseMemberAccessChain(program);
                     if (calcMemberChain) {
                         return [calcMemberChain];
                     }
-                    let calcDeps = collectDependencies(program.object, program, "calculatedMember");
+                    let calcDeps = collectDependencies(program.obj, program, "calculatedMember");
                     return calcDeps.concat(collectDependencies(program.member, program, "calculatedMember"));
-                case "SeqE":
+                case ScriptingSourceTreeExp_1.T_SEQUENCE_EXPRESSION:
                     let sequenceDeps = [];
-                    program.expressions.forEach((expr) => {
+                    program.exprs.forEach((expr) => {
                         sequenceDeps = sequenceDeps.concat(collectDependencies(expr, program, "sequence"));
                     });
                     return sequenceDeps;
-                case "InvokeE":
+                case ScriptingSourceTreeExp_1.T_FUNCTION_INVOCATION_EXPRESSION:
                     let uncDeps = [];
                     (_a = program.arguments) === null || _a === void 0 ? void 0 : _a.forEach((arg) => {
                         uncDeps = uncDeps.concat(collectDependencies(arg, program, "functionInvocation"));
                     });
-                    if (program.object.type === "MembE") {
-                        const caller = program.object;
-                        if (caller.object.type === "IdE") {
-                            if (typeof (0, lodash_es_1.get)(referenceTrackedApis, `${caller.object.name}.${caller.member}`) === "function") {
-                                uncDeps.push(`${caller.object.name}.${caller.member}`);
+                    if (program.obj.type === ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION) {
+                        const caller = program.obj;
+                        if (caller.obj.type === ScriptingSourceTreeExp_1.T_IDENTIFIER) {
+                            if (typeof (0, lodash_es_1.get)(referenceTrackedApis, `${caller.obj.name}.${caller.member}`) ===
+                                "function") {
+                                uncDeps.push(`${caller.obj.name}.${caller.member}`);
                             }
                             else {
-                                uncDeps.push(`${caller.object.name}`);
+                                uncDeps.push(`${caller.obj.name}`);
                             }
                         }
-                        else if (caller.object.type === "MembE" || caller.object.type === "CMembE") {
-                            uncDeps = uncDeps.concat(collectDependencies(caller.object, caller, "functionInvocation"));
+                        else if (caller.obj.type === ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION ||
+                            caller.obj.type === ScriptingSourceTreeExp_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION) {
+                            uncDeps = uncDeps.concat(collectDependencies(caller.obj, caller, "functionInvocation"));
                         }
                         else {
                             uncDeps = uncDeps.concat(collectDependencies(caller, program, "functionInvocation"));
                         }
                     }
                     else {
-                        uncDeps = uncDeps.concat(collectDependencies(program.object, program, "functionInvocation"));
+                        uncDeps = uncDeps.concat(collectDependencies(program.obj, program, "functionInvocation"));
                     }
                     return uncDeps;
-                case "ArrowE":
+                case ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION:
                     // --- Process the current arguments
                     thread.blocks.push({ vars: {} });
                     const block = (0, process_statement_common_1.innermostBlockScope)(thread);
@@ -197,27 +202,30 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
                         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,
+                                    nodeId: argSpec.nodeId,
                                     id: argSpec.name,
                                 };
                                 break;
                             }
-                            case "Destr": {
+                            case ScriptingSourceTreeExp_1.T_DESTRUCTURE: {
                                 decl = {
-                                    type: "VarD",
+                                    type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
+                                    nodeId: argSpec.nodeId,
                                     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,
+                                    nodeId: argSpec.nodeId,
+                                    id: argSpec.expr.name,
                                 };
                                 break;
                             }
@@ -233,7 +241,7 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
                     thread.blocks.pop();
                     // --- Done
                     return arrowDeps;
-                case "OLitE":
+                case ScriptingSourceTreeExp_1.T_OBJECT_LITERAL:
                     let objectDeps = [];
                     program.props.forEach((prop) => {
                         if (Array.isArray(prop)) {
@@ -244,7 +252,7 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
                         }
                     });
                     return objectDeps;
-                case "ALitE":
+                case ScriptingSourceTreeExp_1.T_ARRAY_LITERAL:
                     let arrayDeps = [];
                     program.items.forEach((expr) => {
                         if (expr) {
@@ -252,22 +260,22 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
                         }
                     });
                     return arrayDeps;
-                case "UnaryE":
-                    return collectDependencies(program.operand, program, "unary");
-                case "PrefE":
-                    return collectDependencies(program.operand, program, "prefix");
-                case "PostfE":
-                    return collectDependencies(program.operand, program, "postfix");
-                case "BinaryE":
+                case ScriptingSourceTreeExp_1.T_UNARY_EXPRESSION:
+                    return collectDependencies(program.expr, program, "unary");
+                case ScriptingSourceTreeExp_1.T_PREFIX_OP_EXPRESSION:
+                    return collectDependencies(program.expr, program, "prefix");
+                case ScriptingSourceTreeExp_1.T_POSTFIX_OP_EXPRESSION:
+                    return collectDependencies(program.expr, program, "postfix");
+                case ScriptingSourceTreeExp_1.T_BINARY_EXPRESSION:
                     return collectDependencies(program.left, program, "left").concat(collectDependencies(program.right, program, "right"));
-                case "AsgnE":
-                    return collectDependencies(program.operand, program, "right");
-                case "CondE":
-                    return collectDependencies(program.condition, program, "condition").concat(collectDependencies(program.consequent, program, "trueExpr"), collectDependencies(program.alternate, program, "falseExpr"));
-                case "VarD":
-                    return collectDependencies(program.expression, program, "varDeclaration");
-                case "SpreadE":
-                    return collectDependencies(program.operand, program, "spread");
+                case ScriptingSourceTreeExp_1.T_ASSIGNMENT_EXPRESSION:
+                    return collectDependencies(program.expr, program, "right");
+                case ScriptingSourceTreeExp_1.T_CONDITIONAL_EXPRESSION:
+                    return collectDependencies(program.cond, program, "condition").concat(collectDependencies(program.thenE, program, "trueExpr"), collectDependencies(program.elseE, program, "falseExpr"));
+                case ScriptingSourceTreeExp_1.T_VAR_DECLARATION:
+                    return collectDependencies(program.expr, program, "varDeclaration");
+                case ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION:
+                    return collectDependencies(program.expr, program, "spread");
             }
         }
         return [];
@@ -277,22 +285,22 @@ function collectVariableDependencies(program, referenceTrackedApis = {}) {
     function traverseMemberAccessChain(expr) {
         var _a, _b;
         switch (expr.type) {
-            case "MembE":
-                const memberChain = traverseMemberAccessChain(expr.object);
+            case ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION:
+                const memberChain = traverseMemberAccessChain(expr.obj);
                 return memberChain ? `${memberChain}.${expr.member}` : null;
-            case "CMembE":
+            case ScriptingSourceTreeExp_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
                 let value = null;
-                if (expr.member.type === "LitE") {
+                if (expr.member.type === ScriptingSourceTreeExp_1.T_LITERAL) {
                     value = `'${(_b = (_a = expr.member.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : null}'`;
                 }
-                else if (expr.member.type === "IdE") {
+                else if (expr.member.type === ScriptingSourceTreeExp_1.T_IDENTIFIER) {
                     value = expr.member.name;
                 }
                 if (!value)
                     break;
-                const calcMemberChain = traverseMemberAccessChain(expr.object);
+                const calcMemberChain = traverseMemberAccessChain(expr.obj);
                 return calcMemberChain ? `${calcMemberChain}[${value}]` : null;
-            case "IdE":
+            case ScriptingSourceTreeExp_1.T_IDENTIFIER:
                 const scope = (0, eval_tree_common_1.getIdentifierScope)(expr, evalContext, thread);
                 return scope.type !== "block" ? expr.name : null;
         }
@@ -310,11 +318,11 @@ function processDeclarations(block, declarations) {
         if (decl.id) {
             visitIdDeclaration(block, decl.id);
         }
-        else if (decl.arrayDestruct) {
-            visitArrayDestruct(block, decl.arrayDestruct);
+        else if (decl.aDestr) {
+            visitArrayDestruct(block, decl.aDestr);
         }
-        else if (decl.objectDestruct) {
-            visitObjectDestruct(block, decl.objectDestruct);
+        else if (decl.oDestr) {
+            visitObjectDestruct(block, decl.oDestr);
         }
         else {
             throw new Error("Unknown declaration specifier");
@@ -334,11 +342,11 @@ function processDeclarations(block, declarations) {
             if (arrDecl.id) {
                 visitIdDeclaration(block, arrDecl.id);
             }
-            else if (arrDecl.arrayDestruct) {
-                visitArrayDestruct(block, arrDecl.arrayDestruct);
+            else if (arrDecl.aDestr) {
+                visitArrayDestruct(block, arrDecl.aDestr);
             }
-            else if (arrDecl.objectDestruct) {
-                visitObjectDestruct(block, arrDecl.objectDestruct);
+            else if (arrDecl.oDestr) {
+                visitObjectDestruct(block, arrDecl.oDestr);
             }
         }
     }
@@ -347,11 +355,11 @@ function processDeclarations(block, declarations) {
         var _a;
         for (let i = 0; i < objectD.length; i++) {
             const objDecl = objectD[i];
-            if (objDecl.arrayDestruct) {
-                visitArrayDestruct(block, objDecl.arrayDestruct);
+            if (objDecl.aDestr) {
+                visitArrayDestruct(block, objDecl.aDestr);
             }
-            else if (objDecl.objectDestruct) {
-                visitObjectDestruct(block, objDecl.objectDestruct);
+            else if (objDecl.oDestr) {
+                visitObjectDestruct(block, objDecl.oDestr);
             }
             else {
                 visitIdDeclaration(block, (_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id);

package/dist/scripts/src/components-core/theming/themes/palette.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.palette = void 0;
 exports.palette = {
+    $colorSurface0: "$color-surface-0",
     $colorSurface50: "$color-surface-50",
     $colorSurface100: "$color-surface-100",
     $colorSurface200: "$color-surface-200",