xmlui 0.8.6 → 0.9.1

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

@@ -8,7 +8,6 @@ exports.XmlUiThemeDefinition = {
     // "font.inter": "https://rsms.me/inter/inter.css",
     },
     themeVars: {
-        "boxShadow-header-App": "none",
         "font-size": "15px",
         "boxShadow-Input": "$boxShadow-sm",
     },

package/dist/scripts/src/components-core/theming/transformThemeVars.js

@@ -629,17 +629,17 @@ function generateBaseTonesForColor(varName, theme, options = { distributeEven: f
             color950 = baseColor.lightness(baseL - darkStep * 4.5);
         }
         return {
-            [`${varName}-50`]: color50.toString(),
-            [`${varName}-100`]: color100.toString(),
-            [`${varName}-200`]: color200.toString(),
-            [`${varName}-300`]: color300.toString(),
-            [`${varName}-400`]: color400.toString(),
-            [`${varName}-500`]: color500.toString(),
-            [`${varName}-600`]: color600.toString(),
-            [`${varName}-700`]: color700.toString(),
-            [`${varName}-800`]: color800.toString(),
-            [`${varName}-900`]: color900.toString(),
-            [`${varName}-950`]: color950.toString(),
+            [`const-${varName}-50`]: color50.toString(),
+            [`const-${varName}-100`]: color100.toString(),
+            [`const-${varName}-200`]: color200.toString(),
+            [`const-${varName}-300`]: color300.toString(),
+            [`const-${varName}-400`]: color400.toString(),
+            [`const-${varName}-500`]: color500.toString(),
+            [`const-${varName}-600`]: color600.toString(),
+            [`const-${varName}-700`]: color700.toString(),
+            [`const-${varName}-800`]: color800.toString(),
+            [`const-${varName}-900`]: color900.toString(),
+            [`const-${varName}-950`]: color950.toString(),
         };
     }
     catch (e) {

package/dist/scripts/src/components-core/utils/misc.js

@@ -13,6 +13,7 @@ exports.isPrimitive = exports.pickFromObject = exports.shallowCompare = exports.
 exports.partition = partition;
 exports.generatedId = generatedId;
 exports.randomUUID = randomUUID;
+exports.readCookie = readCookie;
 exports.capitalizeFirstLetter = capitalizeFirstLetter;
 exports.removeNullProperties = removeNullProperties;
 exports.humanFileSize = humanFileSize;
@@ -67,6 +68,18 @@ function randomUUID() {
     // @ts-ignore
     return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
 }
+function readCookie(name) {
+    const nameEQ = name + "=";
+    const ca = document.cookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === ' ')
+            c = c.substring(1, c.length);
+        if (c.indexOf(nameEQ) === 0)
+            return c.substring(nameEQ.length, c.length);
+    }
+    return null;
+}
 /**
  * Wait for a set duration asynchronously.
  * @param ms Time in ms to wait before continuing execution

package/dist/scripts/src/components-core/utils/statementUtils.js

@@ -12,7 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseHandlerCode = parseHandlerCode;
 exports.prepareHandlerStatements = prepareHandlerStatements;
 exports.runEventHandlerCode = runEventHandlerCode;
-const Parser_1 = require("../../parsers/scripting/Parser");
+const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
+const Parser_1 = require("../../parsers/scripting-exp/Parser");
 const process_statement_async_1 = require("../script-runner/process-statement-async");
 const reportEngineError_1 = require("../reportEngineError");
 const EngineError_1 = require("../EngineError");
@@ -48,89 +49,90 @@ function parseHandlerCode(source) {
 }
 /**
  * Optionally transform statements in an event handler to an arrow expression statement
- * @param statements Statements to transform
+ * @param stmts Statements to transform
  * @param evalContext Optional event arguments
  */
-function prepareHandlerStatements(statements, evalContext) {
+function prepareHandlerStatements(stmts, evalContext) {
     var _a;
-    const stmtLength = (_a = statements === null || statements === void 0 ? void 0 : statements.length) !== null && _a !== void 0 ? _a : 0;
+    const stmtLength = (_a = stmts === null || stmts === void 0 ? void 0 : stmts.length) !== null && _a !== void 0 ? _a : 0;
     if (stmtLength === 0) {
         // -- Use a no-op arrow function
         return [
             {
-                type: "ArrowS",
-                expression: {
-                    type: "ArrowE",
+                type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                expr: {
+                    type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
                     args: [],
                     statement: {
-                        type: "EmptyS",
+                        type: ScriptingSourceTreeExp_1.T_EMPTY_STATEMENT,
                     },
                 },
             },
         ];
     }
     if (stmtLength === 1) {
-        const stmt = statements[0];
-        if (stmt.type === "ExprS") {
+        const stmt = stmts[0];
+        if (stmt.type === ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT) {
             // --- Handle single expression statements
             if (evalContext) {
                 // --- We have a context in which the event handler is executed
-                if (stmt.expression.type === "IdE") {
+                if (stmt.expr.type === ScriptingSourceTreeExp_1.T_IDENTIFIER) {
                     // --- A single identifier, it is supposed to be an arrow function
                     // --- Use this arrow expression
-                    return [convertExpressionToFunctionInvocation(stmt.expression)];
+                    return [convertExpressionToFunctionInvocation(stmt.expr)];
                 }
-                if (isMemberExpressionChain(stmt.expression)) {
+                if (isMemberExpressionChain(stmt.expr)) {
                     // --- A single member expression chain, it is supposed to be an arrow function
                     // --- Use this arrow expression
-                    return [convertExpressionToFunctionInvocation(stmt.expression)];
+                    return [convertExpressionToFunctionInvocation(stmt.expr)];
                 }
             }
-            if (stmt.expression.type === "ArrowE") {
+            if (stmt.expr.type === ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
                 // --- A single arrow expression
                 return [
                     {
-                        type: "ArrowS",
-                        expression: stmt.expression,
+                        type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                        expr: stmt.expr,
                     },
                 ];
             }
             // --- A single statement, turn into an arrow expression
             return [
                 {
-                    type: "ArrowS",
-                    expression: {
-                        type: "ArrowE",
+                    type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                    expr: {
+                        type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
                         args: [],
-                        statement: statements[0],
+                        statement: stmts[0],
                     },
                 },
             ];
         }
-        if (stmt.type === "RetS") {
+        if (stmt.type === ScriptingSourceTreeExp_1.T_RETURN_STATEMENT) {
             // --- A single arrow expression with a return
             return [
                 {
-                    type: "ArrowS",
-                    expression: {
-                        type: "ArrowE",
+                    type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                    expr: {
+                        type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
                         args: [],
                         statement: {
-                            type: "BlockS",
-                            statements: [stmt],
+                            type: ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT,
+                            stmts: [stmt],
                         },
                     },
                 },
             ];
         }
-        if (stmt.type === "BlockS") {
+        if (stmt.type === ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT) {
             // --- A single block statement?
-            if (stmt.statements[0].type === "ExprS" && stmt.statements[0].expression.type === "ArrowE") {
+            if (stmt.stmts[0].type === ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT &&
+                stmt.stmts[0].expr.type === ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
                 // --- A single block statement with a single arrow expression?
                 return [
                     {
-                        type: "ArrowS",
-                        expression: stmt.statements[0].expression,
+                        type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                        expr: stmt.stmts[0].expr,
                     },
                 ];
             }
@@ -138,11 +140,11 @@ function prepareHandlerStatements(statements, evalContext) {
                 // --- Consider as a body of a no-arg arrow function
                 return [
                     {
-                        type: "ArrowS",
-                        expression: {
-                            type: "ArrowE",
+                        type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                        expr: {
+                            type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
                             args: [],
-                            statement: statements[0],
+                            statement: stmts[0],
                         },
                     },
                 ];
@@ -153,30 +155,31 @@ function prepareHandlerStatements(statements, evalContext) {
         // --- Use the statements as the body of a no-arg arrow function
         return [
             {
-                type: "ArrowS",
-                expression: {
-                    type: "ArrowE",
+                type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+                expr: {
+                    type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
                     args: [],
                     statement: {
-                        type: "BlockS",
-                        statements,
+                        type: ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT,
+                        stmts,
                     },
                 },
             },
         ];
     }
     // --- Nothing to transform
-    return statements;
+    return stmts;
     function isMemberExpressionChain(expr) {
-        return ((expr.type === "MembE" || (expr.type === "CMembE" && expr.member.type === "LitE")) &&
-            (isMemberExpressionChain(expr.object) || expr.object.type === "IdE"));
+        return ((expr.type === ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION ||
+            (expr.type === ScriptingSourceTreeExp_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION && expr.member.type === ScriptingSourceTreeExp_1.T_LITERAL)) &&
+            (isMemberExpressionChain(expr.obj) || expr.obj.type === ScriptingSourceTreeExp_1.T_IDENTIFIER));
     }
     function convertExpressionToFunctionInvocation(expr) {
         // --- A single identifier, it is supposed to be an arrow function
         // --- Create formal arguments
         const formalArgs = evalContext.eventArgs
             ? evalContext.eventArgs.map((_, idx) => ({
-                type: "IdE",
+                type: ScriptingSourceTreeExp_1.T_IDENTIFIER,
                 name: `__arg@@#__${idx}__`,
             }))
             : [];
@@ -188,21 +191,21 @@ function prepareHandlerStatements(statements, evalContext) {
         }
         // --- Create the arrow expression
         const arrowExpr = {
-            type: "ArrowE",
+            type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
             args: formalArgs,
             statement: {
-                type: "ExprS",
-                expression: {
-                    type: "InvokeE",
-                    object: expr,
+                type: ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT,
+                expr: {
+                    type: ScriptingSourceTreeExp_1.T_FUNCTION_INVOCATION_EXPRESSION,
+                    obj: expr,
                     arguments: [...formalArgs],
                 },
             },
         };
         // --- Use this arrow expression
         return {
-            type: "ArrowS",
-            expression: arrowExpr,
+            type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT,
+            expr: arrowExpr,
         };
     }
 }
@@ -213,9 +216,9 @@ function prepareHandlerStatements(statements, evalContext) {
  * @param thread Logical thread to use
  * @param onStatementCompleted Callback for statement completion
  */
-function runEventHandlerCode(source, evalContext, thread, onStatementCompleted) {
+function runEventHandlerCode(source, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         const statements = prepareHandlerStatements(parseHandlerCode(source));
-        return yield (0, process_statement_async_1.processStatementQueueAsync)(statements, evalContext, thread, onStatementCompleted);
+        return yield (0, process_statement_async_1.processStatementQueueAsync)(statements, evalContext, thread);
     });
 }

package/dist/scripts/src/components-core/xmlui-parser.js

@@ -24,7 +24,7 @@ function xmlUiMarkupToComponent(source, fileId = 0, moduleResolver) {
         return { component: null, errors: errorsWithLines, erroneousCompoundComponentName };
     }
     try {
-        const component = (0, transform_1.nodeToComponentDef)(node, getText, fileId, moduleResolver);
+        const component = (0, transform_1.nodeToComponentDef)(node, getText, fileId);
         const transformResult = { component, errors: [] };
         return transformResult;
     }