xmlui 0.7.13 → 0.7.15

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

@@ -0,0 +1,221 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHandlerCode = parseHandlerCode;
+exports.prepareHandlerStatements = prepareHandlerStatements;
+exports.runEventHandlerCode = runEventHandlerCode;
+const Parser_1 = require("../../parsers/scripting/Parser");
+const process_statement_async_1 = require("../script-runner/process-statement-async");
+const reportEngineError_1 = require("../reportEngineError");
+const EngineError_1 = require("../EngineError");
+/**
+ * Parse the specified source code as event handler code
+ * @param source Event handler source code
+ */
+function parseHandlerCode(source) {
+    // --- Parse the event code
+    const wParser = new Parser_1.Parser(source);
+    let parsedStatements = null;
+    try {
+        // --- Invoke the parser
+        parsedStatements = wParser.parseStatements();
+    }
+    catch (err) {
+        // --- Parsing error with explicit error code
+        if (wParser.errors.length > 0) {
+            const err = wParser.errors[0];
+            (0, reportEngineError_1.reportEngineError)(new EngineError_1.ScriptParseError(`${err.code}(${err.line}, ${err.column}): ${wParser.errors[0].text}`, source, err.position));
+        }
+        else {
+            throw err;
+        }
+    }
+    // --- Check for the completeness of source code parsing
+    if (!wParser.isEof) {
+        const tail = wParser.getTail();
+        (0, reportEngineError_1.reportEngineError)(new EngineError_1.ScriptParseError(`Invalid tail found`, source, source.length - tail.length + 1));
+    }
+    // --- Done
+    return parsedStatements;
+}
+/**
+ * Optionally transform statements in an event handler to an arrow expression statement
+ * @param statements Statements to transform
+ * @param evalContext Optional event arguments
+ */
+function prepareHandlerStatements(statements, evalContext) {
+    var _a;
+    const stmtLength = (_a = statements === null || statements === void 0 ? void 0 : statements.length) !== null && _a !== void 0 ? _a : 0;
+    if (stmtLength === 0) {
+        // -- Use a no-op arrow function
+        return [
+            {
+                type: "ArrowS",
+                expression: {
+                    type: "ArrowE",
+                    args: [],
+                    statement: {
+                        type: "EmptyS",
+                    },
+                },
+            },
+        ];
+    }
+    if (stmtLength === 1) {
+        const stmt = statements[0];
+        if (stmt.type === "ExprS") {
+            // --- Handle single expression statements
+            if (evalContext) {
+                // --- We have a context in which the event handler is executed
+                if (stmt.expression.type === "IdE") {
+                    // --- A single identifier, it is supposed to be an arrow function
+                    // --- Use this arrow expression
+                    return [convertExpressionToFunctionInvocation(stmt.expression)];
+                }
+                if (isMemberExpressionChain(stmt.expression)) {
+                    // --- A single member expression chain, it is supposed to be an arrow function
+                    // --- Use this arrow expression
+                    return [convertExpressionToFunctionInvocation(stmt.expression)];
+                }
+            }
+            if (stmt.expression.type === "ArrowE") {
+                // --- A single arrow expression
+                return [
+                    {
+                        type: "ArrowS",
+                        expression: stmt.expression,
+                    },
+                ];
+            }
+            // --- A single statement, turn into an arrow expression
+            return [
+                {
+                    type: "ArrowS",
+                    expression: {
+                        type: "ArrowE",
+                        args: [],
+                        statement: statements[0],
+                    },
+                },
+            ];
+        }
+        if (stmt.type === "RetS") {
+            // --- A single arrow expression with a return
+            return [
+                {
+                    type: "ArrowS",
+                    expression: {
+                        type: "ArrowE",
+                        args: [],
+                        statement: {
+                            type: "BlockS",
+                            statements: [stmt],
+                        },
+                    },
+                },
+            ];
+        }
+        if (stmt.type === "BlockS") {
+            // --- A single block statement?
+            if (stmt.statements[0].type === "ExprS" && stmt.statements[0].expression.type === "ArrowE") {
+                // --- A single block statement with a single arrow expression?
+                return [
+                    {
+                        type: "ArrowS",
+                        expression: stmt.statements[0].expression,
+                    },
+                ];
+            }
+            else {
+                // --- Consider as a body of a no-arg arrow function
+                return [
+                    {
+                        type: "ArrowS",
+                        expression: {
+                            type: "ArrowE",
+                            args: [],
+                            statement: statements[0],
+                        },
+                    },
+                ];
+            }
+        }
+    }
+    if (stmtLength > 1) {
+        // --- Use the statements as the body of a no-arg arrow function
+        return [
+            {
+                type: "ArrowS",
+                expression: {
+                    type: "ArrowE",
+                    args: [],
+                    statement: {
+                        type: "BlockS",
+                        statements,
+                    },
+                },
+            },
+        ];
+    }
+    // --- Nothing to transform
+    return statements;
+    function isMemberExpressionChain(expr) {
+        return ((expr.type === "MembE" || (expr.type === "CMembE" && expr.member.type === "LitE")) &&
+            (isMemberExpressionChain(expr.object) || expr.object.type === "IdE"));
+    }
+    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",
+                name: `__arg@@#__${idx}__`,
+            }))
+            : [];
+        // --- Add formal argument with current values
+        if (evalContext.eventArgs) {
+            evalContext.eventArgs.forEach((val, idx) => {
+                evalContext.localContext[`__arg@@#__${idx}__`] = val;
+            });
+        }
+        // --- Create the arrow expression
+        const arrowExpr = {
+            type: "ArrowE",
+            args: formalArgs,
+            statement: {
+                type: "ExprS",
+                expression: {
+                    type: "InvokeE",
+                    object: expr,
+                    arguments: [...formalArgs],
+                },
+            },
+        };
+        // --- Use this arrow expression
+        return {
+            type: "ArrowS",
+            expression: arrowExpr,
+        };
+    }
+}
+/**
+ * Runs the specified event handler code
+ * @param source Event handler source code
+ * @param evalContext Evaluation context to use
+ * @param thread Logical thread to use
+ * @param onStatementCompleted Callback for statement completion
+ */
+function runEventHandlerCode(source, evalContext, thread, onStatementCompleted) {
+    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);
+    });
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenNode = flattenNode;
+exports.toFlatTree = toFlatTree;
+exports.walkTree = walkTree;
+exports.unPackTree = unPackTree;
+function flattenNode(node, depth, result, openedIds) {
+    const { children, uid } = node;
+    const isExpanded = openedIds.includes(uid);
+    result.push(Object.assign(Object.assign({}, node), { hasChildren: !!children && children.length > 0, depth,
+        isExpanded }));
+    if (isExpanded && children) {
+        for (let child of children) {
+            flattenNode(child, depth + 1, result, openedIds);
+        }
+    }
+}
+function toFlatTree(treeData, openedIds) {
+    const ret = [];
+    treeData.forEach((node) => {
+        flattenNode(node, 0, ret, openedIds);
+    });
+    return ret;
+}
+function walkTree(treeData, visit) {
+    treeData.forEach((node) => {
+        visit(node);
+        walkTree(node.children || [], visit);
+    });
+}
+function unPackTree(items = [], parentIds = [], parentPath = []) {
+    const treeData = [];
+    let treeItemsById = {};
+    items.forEach((item, index) => {
+        const path = [...parentPath, index];
+        const uid = item.uid || item.cid;
+        const childTree = unPackTree(item.children, [...parentIds, uid], path);
+        const treeItem = Object.assign(Object.assign({}, item), { uid: uid, key: uid, parentIds,
+            path, children: childTree.treeData, selectable: item.selectable });
+        treeData.push(treeItem);
+        treeItemsById[uid] = treeItem;
+        treeItemsById = Object.assign(Object.assign({}, treeItemsById), childTree.treeItemsById);
+    });
+    return {
+        treeData,
+        treeItemsById,
+    };
+}

package/dist/scripts/src/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCssVar = exports.useColors = exports.getColor = exports.Splitter = exports.Button = exports.Stack = exports.Icon = exports.ErrorBoundary = exports.AppRoot = exports.useTheme = exports.startApp = exports.parseScssVar = exports.d = exports.createMetadata = exports.createComponentRenderer = exports.StandaloneApp = void 0;
+const StandaloneApp_1 = __importStar(require("@components-core/StandaloneApp"));
+exports.StandaloneApp = StandaloneApp_1.default;
+Object.defineProperty(exports, "startApp", { enumerable: true, get: function () { return StandaloneApp_1.startApp; } });
+const ComponentDefs_1 = require("@abstractions/ComponentDefs");
+Object.defineProperty(exports, "createMetadata", { enumerable: true, get: function () { return ComponentDefs_1.createMetadata; } });
+Object.defineProperty(exports, "d", { enumerable: true, get: function () { return ComponentDefs_1.d; } });
+const AppRoot_1 = __importDefault(require("@components-core/AppRoot"));
+exports.AppRoot = AppRoot_1.default;
+const renderers_1 = require("@components-core/renderers");
+Object.defineProperty(exports, "createComponentRenderer", { enumerable: true, get: function () { return renderers_1.createComponentRenderer; } });
+const IconNative_1 = require("@components/Icon/IconNative");
+Object.defineProperty(exports, "Icon", { enumerable: true, get: function () { return IconNative_1.Icon; } });
+const ErrorBoundary_1 = require("@components-core/ErrorBoundary");
+Object.defineProperty(exports, "ErrorBoundary", { enumerable: true, get: function () { return ErrorBoundary_1.ErrorBoundary; } });
+const StackNative_1 = require("@components/Stack/StackNative");
+Object.defineProperty(exports, "Stack", { enumerable: true, get: function () { return StackNative_1.Stack; } });
+const ButtonNative_1 = require("@components/Button/ButtonNative");
+Object.defineProperty(exports, "Button", { enumerable: true, get: function () { return ButtonNative_1.Button; } });
+const SplitterNative_1 = require("@components/Splitter/SplitterNative");
+Object.defineProperty(exports, "Splitter", { enumerable: true, get: function () { return SplitterNative_1.Splitter; } });
+const ThemeContext_1 = require("@components-core/theming/ThemeContext");
+Object.defineProperty(exports, "useTheme", { enumerable: true, get: function () { return ThemeContext_1.useTheme; } });
+const StyleParser_1 = require("./parsers/style-parser/StyleParser");
+Object.defineProperty(exports, "toCssVar", { enumerable: true, get: function () { return StyleParser_1.toCssVar; } });
+const css_utils_1 = require("@components-core/utils/css-utils");
+Object.defineProperty(exports, "getColor", { enumerable: true, get: function () { return css_utils_1.getColor; } });
+const hooks_1 = require("@components-core/utils/hooks");
+Object.defineProperty(exports, "useColors", { enumerable: true, get: function () { return hooks_1.useColors; } });
+const themeVars_1 = require("@components-core/theming/themeVars");
+Object.defineProperty(exports, "parseScssVar", { enumerable: true, get: function () { return themeVars_1.parseScssVar; } });

package/dist/scripts/src/parsers/common/GenericToken.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/scripts/src/parsers/scripting-exp/TokenType.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+// Token types available for parsing
+var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["Eof"] = -1] = "Eof";
+    TokenType[TokenType["Ws"] = -2] = "Ws";
+    TokenType[TokenType["BlockComment"] = -3] = "BlockComment";
+    TokenType[TokenType["EolComment"] = -4] = "EolComment";
+    TokenType[TokenType["Unknown"] = 0] = "Unknown";
+    // --- Binding Expression specific tokens
+    TokenType[TokenType["LParent"] = 1] = "LParent";
+    TokenType[TokenType["RParent"] = 2] = "RParent";
+    TokenType[TokenType["Identifier"] = 3] = "Identifier";
+    TokenType[TokenType["Exponent"] = 4] = "Exponent";
+    TokenType[TokenType["Divide"] = 5] = "Divide";
+    TokenType[TokenType["Multiply"] = 6] = "Multiply";
+    TokenType[TokenType["Remainder"] = 7] = "Remainder";
+    TokenType[TokenType["Plus"] = 8] = "Plus";
+    TokenType[TokenType["Minus"] = 9] = "Minus";
+    TokenType[TokenType["BitwiseXor"] = 10] = "BitwiseXor";
+    TokenType[TokenType["BitwiseOr"] = 11] = "BitwiseOr";
+    TokenType[TokenType["LogicalOr"] = 12] = "LogicalOr";
+    TokenType[TokenType["BitwiseAnd"] = 13] = "BitwiseAnd";
+    TokenType[TokenType["LogicalAnd"] = 14] = "LogicalAnd";
+    TokenType[TokenType["IncOp"] = 15] = "IncOp";
+    TokenType[TokenType["DecOp"] = 16] = "DecOp";
+    TokenType[TokenType["Assignment"] = 17] = "Assignment";
+    TokenType[TokenType["AddAssignment"] = 18] = "AddAssignment";
+    TokenType[TokenType["SubtractAssignment"] = 19] = "SubtractAssignment";
+    TokenType[TokenType["ExponentAssignment"] = 20] = "ExponentAssignment";
+    TokenType[TokenType["MultiplyAssignment"] = 21] = "MultiplyAssignment";
+    TokenType[TokenType["DivideAssignment"] = 22] = "DivideAssignment";
+    TokenType[TokenType["RemainderAssignment"] = 23] = "RemainderAssignment";
+    TokenType[TokenType["ShiftLeftAssignment"] = 24] = "ShiftLeftAssignment";
+    TokenType[TokenType["ShiftRightAssignment"] = 25] = "ShiftRightAssignment";
+    TokenType[TokenType["SignedShiftRightAssignment"] = 26] = "SignedShiftRightAssignment";
+    TokenType[TokenType["BitwiseAndAssignment"] = 27] = "BitwiseAndAssignment";
+    TokenType[TokenType["BitwiseXorAssignment"] = 28] = "BitwiseXorAssignment";
+    TokenType[TokenType["BitwiseOrAssignment"] = 29] = "BitwiseOrAssignment";
+    TokenType[TokenType["LogicalAndAssignment"] = 30] = "LogicalAndAssignment";
+    TokenType[TokenType["LogicalOrAssignment"] = 31] = "LogicalOrAssignment";
+    TokenType[TokenType["NullCoalesceAssignment"] = 32] = "NullCoalesceAssignment";
+    TokenType[TokenType["Semicolon"] = 33] = "Semicolon";
+    TokenType[TokenType["Comma"] = 34] = "Comma";
+    TokenType[TokenType["Colon"] = 35] = "Colon";
+    TokenType[TokenType["LSquare"] = 36] = "LSquare";
+    TokenType[TokenType["RSquare"] = 37] = "RSquare";
+    TokenType[TokenType["QuestionMark"] = 38] = "QuestionMark";
+    TokenType[TokenType["NullCoalesce"] = 39] = "NullCoalesce";
+    TokenType[TokenType["OptionalChaining"] = 40] = "OptionalChaining";
+    TokenType[TokenType["BinaryNot"] = 41] = "BinaryNot";
+    TokenType[TokenType["LBrace"] = 42] = "LBrace";
+    TokenType[TokenType["RBrace"] = 43] = "RBrace";
+    TokenType[TokenType["Equal"] = 44] = "Equal";
+    TokenType[TokenType["StrictEqual"] = 45] = "StrictEqual";
+    TokenType[TokenType["LogicalNot"] = 46] = "LogicalNot";
+    TokenType[TokenType["NotEqual"] = 47] = "NotEqual";
+    TokenType[TokenType["StrictNotEqual"] = 48] = "StrictNotEqual";
+    TokenType[TokenType["LessThan"] = 49] = "LessThan";
+    TokenType[TokenType["LessThanOrEqual"] = 50] = "LessThanOrEqual";
+    TokenType[TokenType["ShiftLeft"] = 51] = "ShiftLeft";
+    TokenType[TokenType["GreaterThan"] = 52] = "GreaterThan";
+    TokenType[TokenType["GreaterThanOrEqual"] = 53] = "GreaterThanOrEqual";
+    TokenType[TokenType["ShiftRight"] = 54] = "ShiftRight";
+    TokenType[TokenType["SignedShiftRight"] = 55] = "SignedShiftRight";
+    TokenType[TokenType["Dot"] = 56] = "Dot";
+    TokenType[TokenType["Spread"] = 57] = "Spread";
+    TokenType[TokenType["Global"] = 58] = "Global";
+    TokenType[TokenType["Backtick"] = 59] = "Backtick";
+    TokenType[TokenType["DollarLBrace"] = 60] = "DollarLBrace";
+    TokenType[TokenType["Arrow"] = 61] = "Arrow";
+    TokenType[TokenType["DecimalLiteral"] = 62] = "DecimalLiteral";
+    TokenType[TokenType["HexadecimalLiteral"] = 63] = "HexadecimalLiteral";
+    TokenType[TokenType["BinaryLiteral"] = 64] = "BinaryLiteral";
+    TokenType[TokenType["RealLiteral"] = 65] = "RealLiteral";
+    TokenType[TokenType["StringLiteral"] = 66] = "StringLiteral";
+    TokenType[TokenType["Infinity"] = 67] = "Infinity";
+    TokenType[TokenType["NaN"] = 68] = "NaN";
+    TokenType[TokenType["True"] = 69] = "True";
+    TokenType[TokenType["False"] = 70] = "False";
+    TokenType[TokenType["Typeof"] = 71] = "Typeof";
+    TokenType[TokenType["Null"] = 72] = "Null";
+    TokenType[TokenType["Undefined"] = 73] = "Undefined";
+    TokenType[TokenType["In"] = 74] = "In";
+    TokenType[TokenType["Let"] = 75] = "Let";
+    TokenType[TokenType["Const"] = 76] = "Const";
+    TokenType[TokenType["Var"] = 77] = "Var";
+    TokenType[TokenType["If"] = 78] = "If";
+    TokenType[TokenType["Else"] = 79] = "Else";
+    TokenType[TokenType["Return"] = 80] = "Return";
+    TokenType[TokenType["Break"] = 81] = "Break";
+    TokenType[TokenType["Continue"] = 82] = "Continue";
+    TokenType[TokenType["Do"] = 83] = "Do";
+    TokenType[TokenType["While"] = 84] = "While";
+    TokenType[TokenType["For"] = 85] = "For";
+    TokenType[TokenType["Of"] = 86] = "Of";
+    TokenType[TokenType["Try"] = 87] = "Try";
+    TokenType[TokenType["Catch"] = 88] = "Catch";
+    TokenType[TokenType["Finally"] = 89] = "Finally";
+    TokenType[TokenType["Throw"] = 90] = "Throw";
+    TokenType[TokenType["Switch"] = 91] = "Switch";
+    TokenType[TokenType["Case"] = 92] = "Case";
+    TokenType[TokenType["Default"] = 93] = "Default";
+    TokenType[TokenType["Delete"] = 94] = "Delete";
+    TokenType[TokenType["Function"] = 95] = "Function";
+    TokenType[TokenType["Export"] = 96] = "Export";
+    TokenType[TokenType["Import"] = 97] = "Import";
+    TokenType[TokenType["As"] = 98] = "As";
+    TokenType[TokenType["From"] = 99] = "From";
+})(TokenType || (exports.TokenType = TokenType = {}));

package/dist/scripts/src/parsers/style-parser/StyleInputStream.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyleInputStream = void 0;
+// This class represents the input stream of the layout parser
+class StyleInputStream {
+    // Creates a stream that uses the specified source code
+    constructor(source) {
+        this.source = source;
+        // --- Current stream position
+        this._pos = 0;
+    }
+    // Gets the current position in the stream. Starts from 0.
+    get position() {
+        return this._pos;
+    }
+    // Peeks the next character in the stream. Returns null, if EOF; otherwise the current source code character
+    peek() {
+        return this.ahead(0);
+    }
+    // Looks ahead with `n` characters in the stream. Returns null, if EOF; otherwise the look-ahead character
+    ahead(n = 1) {
+        return this._pos + n > this.source.length - 1 ? null : this.source[this._pos + n];
+    }
+    // Gets the next character from the stream
+    get() {
+        // --- Check for EOF
+        if (this._pos >= this.source.length) {
+            return null;
+        }
+        // --- Get the char, and keep track of position
+        return this.source[this._pos++];
+    }
+    // Gets the tail of the input stream
+    getTail(start) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.substring(start)) !== null && _b !== void 0 ? _b : "";
+    }
+}
+exports.StyleInputStream = StyleInputStream;