xmlui 0.7.14 → 0.7.15

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatementQueue = void 0;
+exports.mapToItem = mapToItem;
+exports.mapStatementsToQueueItems = mapStatementsToQueueItems;
+// --- Implements the statement queue
+class StatementQueue {
+    constructor() {
+        this.items = [];
+    }
+    // --- The current queue length
+    get length() {
+        return this.items.length;
+    }
+    // --- Get the subsequent item in the queue without dequeuing it
+    peek() {
+        return this.items[0];
+    }
+    // --- Remove and return the subsequent item from the queue
+    dequeue() {
+        return this.items.shift();
+    }
+    // --- Push the specified items into the queue and return the corresponding queue items
+    push(statements) {
+        this.items.push(...statements);
+    }
+    // --- Unshift the specified items into the queue in reverse order (starting from the last action) and
+    // --- return the corresponding queue items
+    unshift(statements) {
+        this.items.unshift(...statements);
+    }
+    // --- Remove all items starting from the beginning of the queue, while not reaching the item with the
+    // --- specified label. If the label is found, that remains in the queue; otherwise the queue is emptied
+    clearToLabel(label) {
+        while (this.items.length > 0 && this.items[0].label !== label) {
+            this.items.shift();
+        }
+    }
+}
+exports.StatementQueue = StatementQueue;
+// --- The ID of the last used label
+let nextLabelValue = 1;
+// --- Map a single item to a queue statement list
+function mapToItem(statement) {
+    return [
+        {
+            label: nextLabelValue++,
+            statement: Object.assign({}, statement)
+        }
+    ];
+}
+// --- Map a single statement into a queue item
+function mapStatementToQueueItem(statement) {
+    return {
+        label: nextLabelValue++,
+        statement: Object.assign({}, statement)
+    };
+}
+// --- Map a list of statements into queue items
+function mapStatementsToQueueItems(statements) {
+    return statements.map(mapStatementToQueueItem);
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSyncProxy = getSyncProxy;
+const EngineError_1 = require("@components-core/EngineError");
+/**
+ * Gets a proxy function for one that does not support async operations
+ * @param fn Function to replace with a proxy
+ * @param origArgs Original function arguments
+ * @param context Function context ("this" of the function invocation)
+ * @return The proxy, if found; otherwise the original function
+ */
+function getSyncProxy(fn, origArgs, context) {
+    const proxyInfo = syncProxies.get(fn);
+    if (!proxyInfo)
+        return fn;
+    if (proxyInfo.validator) {
+        const message = proxyInfo.validator(origArgs);
+        if (message) {
+            throw new EngineError_1.StatementExecutionError(message);
+        }
+    }
+    origArgs.unshift(context);
+    return proxyInfo.proxyFn;
+}
+// Async implementations for JavaScript functions that do not support async arguments
+const syncProxies = new Map();
+syncProxies.set(Array.prototype.sort, { proxyFn: sortAborter });
+function sortAborter() {
+    throw new Error("The script engine does not support the sort() method as it " +
+        "sorts an array in-place. Use the toSorted() function instead.");
+}

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

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectVariableDependencies = collectVariableDependencies;
+const lodash_es_1 = require("lodash-es");
+const process_statement_common_1 = require("./process-statement-common");
+const eval_tree_common_1 = require("./eval-tree-common");
+/**
+ * Collects the name of local context variables the specified program depends on
+ * @param program Program to visit
+ * @param referenceTrackedApis
+ */
+function collectVariableDependencies(program, referenceTrackedApis = {}) {
+    // --- We use these variables to keep track of local variable scopes
+    const evalContext = {};
+    const thread = (0, process_statement_common_1.ensureMainThread)(evalContext);
+    const deps = collectDependencies(program);
+    // --- Filter out duplicates
+    return deps.filter((item, index) => deps.indexOf(item) === index);
+    // --- This is the function we call recursively to collect dependencies
+    function collectDependencies(program, parent, tag) {
+        var _a;
+        if (Array.isArray(program)) {
+            // --- Visit statements
+            let deps = [];
+            program.forEach((stmt) => {
+                let stmtDeps = [];
+                switch (stmt.type) {
+                    case "BlockS":
+                        thread.blocks.push({ vars: {} });
+                        stmtDeps = collectDependencies(stmt.statements, stmt, "block");
+                        thread.blocks.pop();
+                        break;
+                    case "ExprS":
+                        stmtDeps = collectDependencies(stmt.expression, stmt, "expression");
+                        break;
+                    case "ArrowS":
+                        thread.blocks.push({ vars: {} });
+                        stmtDeps = collectDependencies(stmt.expression, 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"));
+                            }
+                        });
+                        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"));
+                        }
+                        break;
+                    case "RetS":
+                        if (stmt.expression) {
+                            stmtDeps = collectDependencies(stmt.expression, stmt, "return");
+                        }
+                        break;
+                    case "WhileS":
+                        stmtDeps = collectDependencies(stmt.condition, stmt, "while");
+                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "while"));
+                        break;
+                    case "DoWS":
+                        stmtDeps = collectDependencies(stmt.condition, stmt, "doWhile");
+                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "doWhile"));
+                        break;
+                    case "ForS":
+                        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.update) {
+                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.update, stmt, "for"));
+                        }
+                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "for"));
+                        thread.blocks.pop();
+                        break;
+                    case "ForInS":
+                        thread.blocks.push({ vars: {} });
+                        if (stmt.varBinding !== "none") {
+                            const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                            block.vars[stmt.id] = true;
+                        }
+                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expression, stmt, "forIn"));
+                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "forIn"));
+                        thread.blocks.pop();
+                        break;
+                    case "ForOfS":
+                        thread.blocks.push({ vars: {} });
+                        if (stmt.varBinding !== "none") {
+                            const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                            block.vars[stmt.id] = true;
+                        }
+                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expression, stmt, "forOf"));
+                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "forOf"));
+                        thread.blocks.pop();
+                        break;
+                    case "ThrowS":
+                        stmtDeps = collectDependencies(stmt.expression, stmt, "throw");
+                        break;
+                    case "TryS":
+                        stmtDeps = collectDependencies([stmt.tryBlock], stmt, "try");
+                        if (stmt.catchBlock) {
+                            thread.blocks.push({ vars: {} });
+                            if (stmt.catchVariable) {
+                                const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                                block.vars[stmt.catchVariable] = true;
+                            }
+                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.catchBlock], stmt, "catchBlock"));
+                            thread.blocks.pop();
+                        }
+                        if (stmt.finallyBlock) {
+                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.finallyBlock], stmt, "finallyBlock"));
+                        }
+                        break;
+                    case "SwitchS":
+                        stmtDeps = collectDependencies(stmt.expression, stmt, "switch");
+                        stmt.cases.forEach((c) => {
+                            if (c.caseExpression) {
+                                stmtDeps = stmtDeps.concat(collectDependencies(c.caseExpression, stmt, "switch"));
+                            }
+                            if (c.statements) {
+                                stmtDeps = stmtDeps.concat(collectDependencies(c.statements, stmt, "switch"));
+                            }
+                        });
+                        break;
+                }
+                deps = deps.concat(stmtDeps);
+            });
+            return deps;
+        }
+        else {
+            // --- Visit expression
+            switch (program.type) {
+                case "IdE":
+                    // --- 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":
+                    // --- 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":
+                    // --- 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");
+                    return calcDeps.concat(collectDependencies(program.member, program, "calculatedMember"));
+                case "SeqE":
+                    let sequenceDeps = [];
+                    program.expressions.forEach((expr) => {
+                        sequenceDeps = sequenceDeps.concat(collectDependencies(expr, program, "sequence"));
+                    });
+                    return sequenceDeps;
+                case "InvokeE":
+                    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}`);
+                            }
+                            else {
+                                uncDeps.push(`${caller.object.name}`);
+                            }
+                        }
+                        else if (caller.object.type === "MembE" || caller.object.type === "CMembE") {
+                            uncDeps = uncDeps.concat(collectDependencies(caller.object, caller, "functionInvocation"));
+                        }
+                        else {
+                            uncDeps = uncDeps.concat(collectDependencies(caller, program, "functionInvocation"));
+                        }
+                    }
+                    else {
+                        uncDeps = uncDeps.concat(collectDependencies(program.object, program, "functionInvocation"));
+                    }
+                    return uncDeps;
+                case "ArrowE":
+                    // --- Process the current arguments
+                    thread.blocks.push({ vars: {} });
+                    const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                    const argSpecs = program.args;
+                    let restFound = false;
+                    for (let i = 0; i < argSpecs.length; i++) {
+                        // --- Turn argument specification into processable variable declarations
+                        const argSpec = argSpecs[i];
+                        let decl;
+                        switch (argSpec.type) {
+                            case "IdE": {
+                                decl = {
+                                    type: "VarD",
+                                    id: argSpec.name,
+                                };
+                                break;
+                            }
+                            case "Destr": {
+                                decl = {
+                                    type: "VarD",
+                                    id: argSpec.id,
+                                    arrayDestruct: argSpec.arrayDestruct,
+                                    objectDestruct: argSpec.objectDestruct,
+                                };
+                                break;
+                            }
+                            case "SpreadE": {
+                                restFound = true;
+                                decl = {
+                                    type: "VarD",
+                                    id: argSpec.operand.name,
+                                };
+                                break;
+                            }
+                            default:
+                                throw new Error("Unexpected arrow argument specification");
+                        }
+                        // --- Process declarations
+                        processDeclarations(block, [decl]);
+                    }
+                    // --- Process the arrow expression's body
+                    const arrowDeps = collectDependencies([program.statement], program, "arrow");
+                    // --- Remove the block scope
+                    thread.blocks.pop();
+                    // --- Done
+                    return arrowDeps;
+                case "OLitE":
+                    let objectDeps = [];
+                    program.props.forEach((prop) => {
+                        if (Array.isArray(prop)) {
+                            objectDeps = objectDeps.concat(collectDependencies(prop[1], program, "objectLiteral"));
+                        }
+                        else {
+                            objectDeps = objectDeps.concat(collectDependencies(prop, program, "objectLiteral"));
+                        }
+                    });
+                    return objectDeps;
+                case "ALitE":
+                    let arrayDeps = [];
+                    program.items.forEach((expr) => {
+                        if (expr) {
+                            arrayDeps = arrayDeps.concat(collectDependencies(expr, program, "array"));
+                        }
+                    });
+                    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":
+                    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");
+            }
+        }
+        return [];
+    }
+    // --- Traverses a member access chain. Returns the chain as a string or null
+    // --- if the chain is not simple
+    function traverseMemberAccessChain(expr) {
+        var _a, _b;
+        switch (expr.type) {
+            case "MembE":
+                const memberChain = traverseMemberAccessChain(expr.object);
+                return memberChain ? `${memberChain}.${expr.member}` : null;
+            case "CMembE":
+                let value = null;
+                if (expr.member.type === "LitE") {
+                    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") {
+                    value = expr.member.name;
+                }
+                if (!value)
+                    break;
+                const calcMemberChain = traverseMemberAccessChain(expr.object);
+                return calcMemberChain ? `${calcMemberChain}[${value}]` : null;
+            case "IdE":
+                const scope = (0, eval_tree_common_1.getIdentifierScope)(expr, evalContext, thread);
+                return scope.type !== "block" ? expr.name : null;
+        }
+        return null;
+    }
+}
+// --- Process a variable declaration
+function processDeclarations(block, declarations) {
+    for (let i = 0; i < declarations.length; i++) {
+        visitDeclaration(block, declarations[i]);
+    }
+    // --- Visit a variable
+    function visitDeclaration(block, decl) {
+        // --- Process each declaration
+        if (decl.id) {
+            visitIdDeclaration(block, decl.id);
+        }
+        else if (decl.arrayDestruct) {
+            visitArrayDestruct(block, decl.arrayDestruct);
+        }
+        else if (decl.objectDestruct) {
+            visitObjectDestruct(block, decl.objectDestruct);
+        }
+        else {
+            throw new Error("Unknown declaration specifier");
+        }
+    }
+    // --- Visits a single ID declaration
+    function visitIdDeclaration(block, id) {
+        if (block.vars[id]) {
+            throw new Error(`Variable ${id} is already declared in the current scope.`);
+        }
+        block.vars[id] = true;
+    }
+    // --- Visits an array destructure declaration
+    function visitArrayDestruct(block, arrayD) {
+        for (let i = 0; i < arrayD.length; i++) {
+            const arrDecl = arrayD[i];
+            if (arrDecl.id) {
+                visitIdDeclaration(block, arrDecl.id);
+            }
+            else if (arrDecl.arrayDestruct) {
+                visitArrayDestruct(block, arrDecl.arrayDestruct);
+            }
+            else if (arrDecl.objectDestruct) {
+                visitObjectDestruct(block, arrDecl.objectDestruct);
+            }
+        }
+    }
+    // --- Visits an object destructure declaration
+    function visitObjectDestruct(block, objectD) {
+        var _a;
+        for (let i = 0; i < objectD.length; i++) {
+            const objDecl = objectD[i];
+            if (objDecl.arrayDestruct) {
+                visitArrayDestruct(block, objDecl.arrayDestruct);
+            }
+            else if (objDecl.objectDestruct) {
+                visitObjectDestruct(block, objDecl.objectDestruct);
+            }
+            else {
+                visitIdDeclaration(block, (_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemesContext = exports.ThemeContext = void 0;
+exports.useTheme = useTheme;
+exports.useThemes = useThemes;
+exports.useResourceUrl = useResourceUrl;
+const react_1 = __importStar(require("react"));
+exports.ThemeContext = react_1.default.createContext(undefined);
+exports.ThemesContext = react_1.default.createContext(undefined);
+// This React hook makes the current theme information available within any component logic using the hook.
+function useTheme() {
+    return (0, react_1.useContext)(exports.ThemeContext);
+}
+function useThemes() {
+    return (0, react_1.useContext)(exports.ThemesContext);
+}
+function useResourceUrl(resourceString) {
+    const { getResourceUrl } = useTheme();
+    return getResourceUrl(resourceString);
+}