xmlui 0.11.3 → 0.11.6

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

@@ -1,224 +0,0 @@
-"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 ScriptingSourceTree_1 = require("../script-runner/ScriptingSourceTree");
-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 stmts Statements to transform
- * @param evalContext Optional event arguments
- */
-function prepareHandlerStatements(stmts, evalContext) {
-    var _a;
-    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: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                expr: {
-                    type: ScriptingSourceTree_1.T_ARROW_EXPRESSION,
-                    args: [],
-                    statement: {
-                        type: ScriptingSourceTree_1.T_EMPTY_STATEMENT,
-                    },
-                },
-            },
-        ];
-    }
-    if (stmtLength === 1) {
-        const stmt = stmts[0];
-        if (stmt.type === ScriptingSourceTree_1.T_EXPRESSION_STATEMENT) {
-            // --- Handle single expression statements
-            if (evalContext) {
-                // --- We have a context in which the event handler is executed
-                if (stmt.expr.type === ScriptingSourceTree_1.T_IDENTIFIER) {
-                    // --- A single identifier, it is supposed to be an arrow function
-                    // --- Use this arrow expression
-                    return [convertExpressionToFunctionInvocation(stmt.expr)];
-                }
-                if (isMemberExpressionChain(stmt.expr)) {
-                    // --- A single member expression chain, it is supposed to be an arrow function
-                    // --- Use this arrow expression
-                    return [convertExpressionToFunctionInvocation(stmt.expr)];
-                }
-            }
-            if (stmt.expr.type === ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-                // --- A single arrow expression
-                return [
-                    {
-                        type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                        expr: stmt.expr,
-                    },
-                ];
-            }
-            // --- A single statement, turn into an arrow expression
-            return [
-                {
-                    type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                    expr: {
-                        type: ScriptingSourceTree_1.T_ARROW_EXPRESSION,
-                        args: [],
-                        statement: stmts[0],
-                    },
-                },
-            ];
-        }
-        if (stmt.type === ScriptingSourceTree_1.T_RETURN_STATEMENT) {
-            // --- A single arrow expression with a return
-            return [
-                {
-                    type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                    expr: {
-                        type: ScriptingSourceTree_1.T_ARROW_EXPRESSION,
-                        args: [],
-                        statement: {
-                            type: ScriptingSourceTree_1.T_BLOCK_STATEMENT,
-                            stmts: [stmt],
-                        },
-                    },
-                },
-            ];
-        }
-        if (stmt.type === ScriptingSourceTree_1.T_BLOCK_STATEMENT) {
-            // --- A single block statement?
-            if (stmt.stmts[0].type === ScriptingSourceTree_1.T_EXPRESSION_STATEMENT &&
-                stmt.stmts[0].expr.type === ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-                // --- A single block statement with a single arrow expression?
-                return [
-                    {
-                        type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                        expr: stmt.stmts[0].expr,
-                    },
-                ];
-            }
-            else {
-                // --- Consider as a body of a no-arg arrow function
-                return [
-                    {
-                        type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                        expr: {
-                            type: ScriptingSourceTree_1.T_ARROW_EXPRESSION,
-                            args: [],
-                            statement: stmts[0],
-                        },
-                    },
-                ];
-            }
-        }
-    }
-    if (stmtLength > 1) {
-        // --- Use the statements as the body of a no-arg arrow function
-        return [
-            {
-                type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-                expr: {
-                    type: ScriptingSourceTree_1.T_ARROW_EXPRESSION,
-                    args: [],
-                    statement: {
-                        type: ScriptingSourceTree_1.T_BLOCK_STATEMENT,
-                        stmts,
-                    },
-                },
-            },
-        ];
-    }
-    // --- Nothing to transform
-    return stmts;
-    function isMemberExpressionChain(expr) {
-        return ((expr.type === ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION ||
-            (expr.type === ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION && expr.member.type === ScriptingSourceTree_1.T_LITERAL)) &&
-            (isMemberExpressionChain(expr.obj) || expr.obj.type === ScriptingSourceTree_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: ScriptingSourceTree_1.T_IDENTIFIER,
-                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: ScriptingSourceTree_1.T_ARROW_EXPRESSION,
-            args: formalArgs,
-            statement: {
-                type: ScriptingSourceTree_1.T_EXPRESSION_STATEMENT,
-                expr: {
-                    type: ScriptingSourceTree_1.T_FUNCTION_INVOCATION_EXPRESSION,
-                    obj: expr,
-                    arguments: [...formalArgs],
-                },
-            },
-        };
-        // --- Use this arrow expression
-        return {
-            type: ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT,
-            expr: 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) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const statements = prepareHandlerStatements(parseHandlerCode(source));
-        return yield (0, process_statement_async_1.processStatementQueueAsync)(statements, evalContext, thread);
-    });
-}

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

@@ -1,226 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenNode = flattenNode;
-exports.toFlatTree = toFlatTree;
-exports.walkTree = walkTree;
-exports.unPackTree = unPackTree;
-exports.flatToNative = flatToNative;
-exports.hierarchyToNative = hierarchyToNative;
-function flattenNode(node, depth, result, openedIds, dynamicField, nodeStates) {
-    const { children, key } = node;
-    const isExpanded = openedIds.includes(key);
-    // Check if node has actual children OR is a dynamic node that can load children
-    const hasActualChildren = !!children && children.length > 0;
-    const isDynamic = dynamicField && node[dynamicField];
-    const hasChildren = hasActualChildren || isDynamic;
-    // Get loading state for this node
-    const loadingState = (nodeStates === null || nodeStates === void 0 ? void 0 : nodeStates.get(key)) || (isDynamic ? 'unloaded' : 'loaded');
-    const flatNode = Object.assign(Object.assign({}, node), { hasChildren,
-        depth,
-        isExpanded,
-        loadingState, 
-        // Ensure key is preserved (in case it was overwritten by ...node spread)
-        key: key || node.key || node.id });
-    result.push(flatNode);
-    if (isExpanded && children) {
-        for (let child of children) {
-            flattenNode(child, depth + 1, result, openedIds, dynamicField, nodeStates);
-        }
-    }
-}
-function toFlatTree(treeData, openedIds, dynamicField, nodeStates) {
-    const ret = [];
-    treeData.forEach((node) => {
-        flattenNode(node, 0, ret, openedIds, dynamicField, nodeStates);
-    });
-    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 id = item.id || item.cid;
-        const childTree = unPackTree(item.children, [...parentIds, id], path);
-        const treeItem = Object.assign(Object.assign({}, item), { id: id, key: id, parentIds,
-            path, children: childTree.treeData, selectable: item.selectable });
-        treeData.push(treeItem);
-        treeItemsById[id] = treeItem;
-        treeItemsById = Object.assign(Object.assign({}, treeItemsById), childTree.treeItemsById);
-    });
-    return {
-        treeData,
-        treeItemsById,
-    };
-}
-/**
- * Transforms flat array data with parent-child relationships into UnPackedTreeData format
- * @param flatData Array of flat objects with id and parentId relationships
- * @param fieldConfig Configuration for mapping object fields to tree properties
- * @returns UnPackedTreeData structure suitable for Tree component
- */
-function flatToNative(flatData, fieldConfig) {
-    if (!flatData || flatData.length === 0) {
-        return { treeData: [], treeItemsById: {} };
-    }
-    // Build parent-to-children map for efficient lookup
-    const childrenMap = new Map();
-    const itemsById = new Map();
-    const rootItems = [];
-    // First pass: organize items and build relationships
-    flatData.forEach(item => {
-        const id = item[fieldConfig.idField];
-        const parentId = item[fieldConfig.parentField || 'parentId'];
-        // Store item for lookup
-        itemsById.set(id, item);
-        if (parentId && parentId !== '') {
-            // Convert parentId to string for consistent type in childrenMap
-            const parentKey = String(parentId);
-            // Has parent - add to children map
-            if (!childrenMap.has(parentKey)) {
-                childrenMap.set(parentKey, []);
-            }
-            childrenMap.get(parentKey).push(item);
-        }
-        else {
-            // Root item
-            rootItems.push(item);
-        }
-    });
-    // Generate unique IDs for internal tree structure
-    let idCounter = 1;
-    const sourceIdToId = new Map();
-    const getOrCreateId = (sourceId) => {
-        if (!sourceIdToId.has(sourceId)) {
-            sourceIdToId.set(sourceId, `flat_${idCounter++}`);
-        }
-        return sourceIdToId.get(sourceId);
-    };
-    // Recursive function to build TreeNode structure
-    const buildTreeNode = (item, parentIds = [], pathSegments = []) => {
-        var _a;
-        const sourceId = item[fieldConfig.idField];
-        const id = getOrCreateId(sourceId);
-        const displayName = item[fieldConfig.labelField] || sourceId;
-        const currentPath = [...pathSegments, displayName];
-        // Get children for this item
-        const sourceKey = String(sourceId);
-        const childItems = childrenMap.get(sourceKey) || [];
-        const children = childItems.map(childItem => buildTreeNode(childItem, [...parentIds, sourceId], currentPath));
-        // Build the TreeNode
-        const treeNode = Object.assign(Object.assign(Object.assign(Object.assign({ id, key: sourceId, path: currentPath, displayName,
-            parentIds, selectable: fieldConfig.selectableField ? ((_a = item[fieldConfig.selectableField]) !== null && _a !== void 0 ? _a : true) : true, children }, item), (fieldConfig.iconField && item[fieldConfig.iconField] && {
-            icon: item[fieldConfig.iconField]
-        })), (fieldConfig.iconExpandedField && item[fieldConfig.iconExpandedField] && {
-            iconExpanded: item[fieldConfig.iconExpandedField]
-        })), (fieldConfig.iconCollapsedField && item[fieldConfig.iconCollapsedField] && {
-            iconCollapsed: item[fieldConfig.iconCollapsedField]
-        }));
-        return treeNode;
-    };
-    // Build tree structure from root items
-    const treeData = rootItems.map(rootItem => buildTreeNode(rootItem));
-    // Build lookup map by ID
-    const treeItemsById = {};
-    const collectNodes = (nodes) => {
-        nodes.forEach(node => {
-            treeItemsById[node.id] = node;
-            if (node.children) {
-                collectNodes(node.children);
-            }
-        });
-    };
-    collectNodes(treeData);
-    return {
-        treeData,
-        treeItemsById,
-    };
-}
-/**
- * Transforms hierarchical nested object data into UnPackedTreeData format
- * @param hierarchyData Single object or array of objects with nested children structure
- * @param fieldConfig Configuration for mapping object fields to tree properties
- * @returns UnPackedTreeData structure suitable for Tree component
- */
-function hierarchyToNative(hierarchyData, fieldConfig) {
-    if (!hierarchyData) {
-        return { treeData: [], treeItemsById: {} };
-    }
-    // Ensure we're working with an array
-    const rootItems = Array.isArray(hierarchyData) ? hierarchyData : [hierarchyData];
-    if (rootItems.length === 0) {
-        return { treeData: [], treeItemsById: {} };
-    }
-    // Generate unique IDs for internal tree structure
-    let idCounter = 1;
-    const sourceIdToId = new Map();
-    const getOrCreateId = (sourceId) => {
-        if (!sourceIdToId.has(sourceId)) {
-            sourceIdToId.set(sourceId, `hierarchy_${idCounter++}`);
-        }
-        return sourceIdToId.get(sourceId);
-    };
-    // Set to track visited nodes for circular reference detection
-    const visitedIds = new Set();
-    // Recursive function to build TreeNode structure from hierarchical data
-    const buildTreeNode = (item, parentIds = [], pathSegments = []) => {
-        var _a, _b;
-        const sourceId = item[fieldConfig.idField];
-        const displayName = item[fieldConfig.labelField] || sourceId;
-        // Circular reference detection
-        if (visitedIds.has(sourceId)) {
-            // Return a simple node without children to break the cycle
-            const id = getOrCreateId(sourceId);
-            return Object.assign(Object.assign({ id, key: sourceId, path: [...pathSegments, displayName], displayName,
-                parentIds, selectable: fieldConfig.selectableField ? ((_a = item[fieldConfig.selectableField]) !== null && _a !== void 0 ? _a : true) : true, children: [] }, item), (fieldConfig.iconField && item[fieldConfig.iconField] && {
-                icon: item[fieldConfig.iconField]
-            }));
-        }
-        // Mark as visited
-        visitedIds.add(sourceId);
-        const id = getOrCreateId(sourceId);
-        const currentPath = [...pathSegments, displayName];
-        // Get children from the specified children field
-        const childrenField = fieldConfig.childrenField || 'children';
-        const childItems = item[childrenField] || [];
-        // Recursively build children
-        const children = childItems.map((childItem) => buildTreeNode(childItem, [...parentIds, sourceId], currentPath));
-        // Unmark as visited after processing (for depth-first traversal)
-        visitedIds.delete(sourceId);
-        // Build the TreeNode
-        const treeNode = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ id, path: currentPath, displayName,
-            parentIds, selectable: fieldConfig.selectableField ? ((_b = item[fieldConfig.selectableField]) !== null && _b !== void 0 ? _b : true) : true }, item), (fieldConfig.iconField && item[fieldConfig.iconField] && {
-            icon: item[fieldConfig.iconField]
-        })), (fieldConfig.iconExpandedField && item[fieldConfig.iconExpandedField] && {
-            iconExpanded: item[fieldConfig.iconExpandedField]
-        })), (fieldConfig.iconCollapsedField && item[fieldConfig.iconCollapsedField] && {
-            iconCollapsed: item[fieldConfig.iconCollapsedField]
-        })), { 
-            // Set TreeNode-specific properties AFTER spreading item to ensure they're not overwritten
-            children, key: sourceId });
-        return treeNode;
-    };
-    // Build tree structure from root items
-    const treeData = rootItems.map(rootItem => buildTreeNode(rootItem));
-    // Build lookup map by ID
-    const treeItemsById = {};
-    const collectNodes = (nodes) => {
-        nodes.forEach(node => {
-            treeItemsById[node.id] = node;
-            if (node.children) {
-                collectNodes(node.children);
-            }
-        });
-    };
-    collectNodes(treeData);
-    return {
-        treeData,
-        treeItemsById,
-    };
-}