@lcap/nasl-concepts 3.13.0-alpha.microapp-1 → 3.13.0-beta.10

package/out/concepts/BatchAssignment__.js

@@ -36,6 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchAssignment = void 0;
 const utils_1 = require("../utils");
 const nasl_translator_1 = require("@lcap/nasl-translator");
+var MatchingStrategies;
+(function (MatchingStrategies) {
+    MatchingStrategies["BY_NAME"] = "BY_NAME";
+    MatchingStrategies["BY_TYPE"] = "BY_TYPE";
+    MatchingStrategies["BY_NAME_AND_TYPE"] = "BY_NAME_AND_TYPE";
+    MatchingStrategies["BY_TOP_DOWN"] = "BY_TOP_DOWN";
+})(MatchingStrategies || (MatchingStrategies = {}));
 const decorators_1 = require("../decorators");
 const utils = __importStar(require("../utils"));
 const asserts = __importStar(require("./utils/asserts"));
@@ -72,6 +79,8 @@ let BatchAssignment = class BatchAssignment extends LogicItem__1.default {
          * 自动连线
          */
         this.autoConnection = true;
+        // 匹配策略
+        this.matchingStrategy = MatchingStrategies.BY_NAME_AND_TYPE;
         super.subConstructor(source);
     }
     static from(source, parentNode, parentKey) {
@@ -289,9 +298,219 @@ let BatchAssignment = class BatchAssignment extends LogicItem__1.default {
             },
         };
     }
-    // 自动连线算法---addRightIndex : 指右边选择变量后对该selectmember进行自动连线。
-    batchAutoConnection(addRightIndex) {
+    checkConditions({ leftName, rightName, leftTypeAnnotation, rightTypeAnnotation, }) {
+        // 条件数组
+        const conditions = [];
+        if ([
+            MatchingStrategies.BY_NAME,
+            MatchingStrategies.BY_NAME_AND_TYPE,
+        ].includes(this.matchingStrategy)) {
+            conditions.push(() => {
+                return leftName === rightName;
+            });
+        }
+        if ([
+            MatchingStrategies.BY_TYPE,
+            MatchingStrategies.BY_NAME_AND_TYPE,
+        ].includes(this.matchingStrategy)) {
+            conditions.push(() => {
+                return rightTypeAnnotation?.sortedTypeKey === leftTypeAnnotation.sortedTypeKey;
+            });
+        }
+        if ([
+            MatchingStrategies.BY_TOP_DOWN,
+        ].includes(this.matchingStrategy)) {
+            conditions.push(() => {
+                return true;
+            });
+        }
+        return conditions.every(condition => condition());
+    }
+    // 替换变量
+    async replaceIdentifier(oldNode, expression, members) {
+        // 关闭定时
+        this.app._noTimer = true;
+        this.app.emit('collect:start', {
+            actionMsg: '替换变量',
+        });
+        // 被替换的第一层属性
+        const oldSelectMember = oldNode.parentNode;
+        const newSelectMember = {
+            ...(oldSelectMember?.toJSON?.() ?? oldSelectMember),
+            expression,
+            members: [],
+        };
+        // 如果替换的是右侧
+        let firstRightIndex = -1;
+        const params = {};
+        // 待定的连线（保留的属性的连线也要保留）
+        const pendingLinesMap = new Map();
+        let newLines = [];
+        // 如果替换的是左侧
+        if (oldSelectMember.parentKey === 'left') {
+            params.left = newSelectMember;
+            newLines = this.assignmentLines.filter((line) => {
+                const { leftIndex } = line;
+                const [first, second] = leftIndex || [];
+                if (leftIndex.length === 2) {
+                    if (!pendingLinesMap.get(second)) {
+                        pendingLinesMap.set(second, []);
+                    }
+                    const lines = pendingLinesMap.get(second);
+                    lines.push(line);
+                    return false;
+                }
+                return true;
+            });
+        }
+        else {
+            firstRightIndex = this.rights.findIndex((right) => {
+                return oldSelectMember === right;
+            });
+            params.rights = [
+                ...this.rights.slice(0, firstRightIndex),
+                newSelectMember,
+                ...this.rights.slice(firstRightIndex + 1, this.rights.length),
+            ];
+            newLines = this.assignmentLines.filter((line) => {
+                const { rightIndex } = line;
+                const [first, second] = rightIndex || [];
+                if (rightIndex.length === 2 && first === firstRightIndex) {
+                    if (!pendingLinesMap.get(second)) {
+                        pendingLinesMap.set(second, []);
+                    }
+                    const lines = pendingLinesMap.get(second);
+                    lines.push(line);
+                    return false;
+                }
+                return true;
+            });
+        }
+        // 先用变量替换右侧的属性
+        this.update({
+            ...params,
+            assignmentLines: newLines,
+        });
+        // 触发ts类型标注
+        this.app.naslServer?.embeddedTSEmitter.emit('change', {
+            value: [
+                {
+                    originEvent: {
+                        action: 'update',
+                        target: this,
+                    },
+                },
+            ],
+        });
+        const memberInfoMap = new Map();
+        // 获取拖入表达式的类型
+        const currTypeAnnotation = await newSelectMember.expression?.getCurrentTypeAnnotation(30000);
+        // 当前类型下的所有属性（递归）
+        const propertyMap = currTypeAnnotation?.collectPropertyMap?.(this.app);
+        if (propertyMap) {
+            oldSelectMember?.members.forEach((member, index) => {
+                // 完整属性名
+                const oldCompletePropertyName = member.completePropertyName;
+                const { typeAnnotation, __TypeAnnotation } = member || {};
+                // 属性类型
+                const memberTypeAnnotation = typeAnnotation || __TypeAnnotation;
+                if (propertyMap.get(oldCompletePropertyName)?.typeKey === memberTypeAnnotation?.typeKey) {
+                    memberInfoMap.set(oldCompletePropertyName, {
+                        orginIndex: index,
+                        member,
+                    });
+                }
+            });
+        }
+        members.forEach((member) => {
+            const { completePropertyName } = member || {};
+            if (!memberInfoMap.has(completePropertyName)) {
+                memberInfoMap.set(completePropertyName, {
+                    orginIndex: -1,
+                    member,
+                });
+            }
+        });
+        const memberInfos = [...memberInfoMap.values()];
+        if (propertyMap) {
+            memberInfos.sort((member1, member2) => {
+                return propertyMap.get(member1?.member?.completePropertyName)?.index - propertyMap.get(member2?.member?.completePropertyName)?.index;
+            });
+        }
+        // 保留的左侧属性
+        const reservedLeftIndex = [];
+        // 保留的右侧属性
+        const reservedRightIndex = [];
+        let targetSelectMembers;
+        if (oldSelectMember.parentKey === 'left') {
+            memberInfos.forEach(({ orginIndex, }, index) => {
+                if (orginIndex !== -1) {
+                    reservedLeftIndex.push(index);
+                    const pendingLines = pendingLinesMap.get(orginIndex);
+                    if (Array.isArray(pendingLines)) {
+                        pendingLines.forEach((pendingLine) => {
+                            const newLine = {
+                                ...(pendingLine?.toJSON?.() ?? pendingLine),
+                                leftIndex: [0, index],
+                            };
+                            newLines.push(newLine);
+                        });
+                    }
+                }
+            });
+            targetSelectMembers = this.left;
+        }
+        else {
+            memberInfos.forEach(({ orginIndex, }, index) => {
+                if (orginIndex !== -1) {
+                    reservedRightIndex.push(`${firstRightIndex}_${index}`);
+                    const pendingLines = pendingLinesMap.get(orginIndex);
+                    if (Array.isArray(pendingLines)) {
+                        pendingLines.forEach((pendingLine) => {
+                            const newLine = {
+                                ...(pendingLine?.toJSON?.() ?? pendingLine),
+                                rightIndex: [pendingLine.rightIndex[0], index],
+                            };
+                            newLines.push(newLine);
+                        });
+                    }
+                }
+            });
+            targetSelectMembers = this.rights[firstRightIndex];
+        }
+        if (targetSelectMembers) {
+            const MemberExpression = (0, decorators_1.getConceptConstructor)('MemberExpression');
+            targetSelectMembers.update({
+                members: memberInfos.map(({ member, }) => {
+                    return new MemberExpression({
+                        ...(member?.firstMemberExpressionNode?.()?.toJSON() || {}),
+                        object: expression?.toJSON(),
+                    });
+                }),
+            });
+        }
+        // 更新属性和连线
+        this.update({
+            assignmentLines: newLines,
+        });
+        this.autoConnection && this.batchAutoConnection({
+            targetRightIndex: firstRightIndex,
+            reservedRightIndex,
+            reservedLeftIndex,
+        });
+        this.app.emit('collect:end');
+    }
+    /**
+     * 自动连线算法
+     * @param param0
+     */
+    batchAutoConnection({ targetRightIndex, reservedLeftIndex, reservedRightIndex, }) {
         const leftLineSet = new Set();
+        if (Array.isArray(reservedLeftIndex)) {
+            reservedLeftIndex.forEach((index) => {
+                leftLineSet.add(index);
+            });
+        }
         const lineArr = [];
         const AssignmentLine = (0, decorators_1.getConceptConstructor)('AssignmentLine');
         // 系统属性不可自动连线
@@ -314,72 +533,131 @@ let BatchAssignment = class BatchAssignment extends LogicItem__1.default {
             this.app.emit('collect:start', {
                 actionMsg: '自动连线',
             });
-            this.left.members.forEach((member, leftSecondIndex) => {
-                const leftValue = member.getValue();
-                const leftName = member.property?.name;
-                const leftTypeAnnotation = member.__TypeAnnotation;
-                if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName))
-                    return;
-                this.rights.forEach((selectMember, rightFirstIndex) => {
-                    const { members, expression } = selectMember;
-                    if (leftLineSet.has(leftSecondIndex))
-                        return;
-                    if (![-1, null, undefined].includes(addRightIndex) && addRightIndex !== rightFirstIndex)
-                        return;
-                    // 右侧父节点也不允许自动连线
-                    const rightLineSet = new Set();
+            // 目标右侧
+            const targetRights = [-1, null, undefined].includes(targetRightIndex) ? this.rights.map((right, index) => {
+                return {
+                    right,
+                    index,
+                };
+            }) : [
+                {
+                    right: this.rights?.[targetRightIndex],
+                    index: targetRightIndex,
+                },
+            ];
+            // 右侧父节点也不允许自动连线
+            const rightLineSet = new Set();
+            if (Array.isArray(reservedRightIndex) && reservedRightIndex.length) {
+                reservedRightIndex.forEach((rightIndex) => {
+                    rightLineSet.add(rightIndex);
+                });
+            }
+            if (targetRights) {
+                targetRights.forEach(({ right: targetRight, index, }) => {
+                    const { members } = targetRight;
                     for (let i = 0; i < members.length - 1; i++) {
                         const { completeName } = members[i];
                         const preCompleteName = members[i + 1].completeName;
                         if (preCompleteName.includes(completeName) &&
-                            completeName.split('.').length !== preCompleteName.split('.').length)
-                            rightLineSet.add(i);
+                            completeName.split('.').length !== preCompleteName.split('.').length) {
+                            rightLineSet.add(`${index}_${i}`);
+                        }
+                    }
+                });
+            }
+            this.assignmentLines.forEach((assignmentLine) => {
+                const { rightIndex } = assignmentLine;
+                if (rightIndex.length === 1) {
+                    rightLineSet.add(`${rightIndex?.[0]}`);
+                }
+                else if (rightIndex.length === 2) {
+                    const [firstIndex, secondIndex] = rightIndex || [];
+                    rightLineSet.add(`${firstIndex}_${secondIndex}`);
+                }
+            });
+            this.left.members.forEach((member, leftSecondIndex) => {
+                const leftName = member.property?.name;
+                const leftTypeAnnotation = member.__TypeAnnotation;
+                targetRights.forEach(({ right: targetRight, index: rightFirstIndex, }) => {
+                    // 已经有连线的不需要自动连线
+                    if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName)) {
+                        return;
                     }
-                    if (leftName === expression.name && expression.__TypeAnnotation?.typeKind === leftTypeAnnotation.typeKind) {
+                    const { members, expression } = targetRight;
+                    if (members?.length) {
+                        members.forEach((rightMember, rightSecondIndex) => {
+                            // 已经有连线的不需要自动连线
+                            if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName)) {
+                                return;
+                            }
+                            if (rightLineSet.has(`${rightFirstIndex}_${rightSecondIndex}`)) {
+                                return;
+                            }
+                            const rightName = rightMember.property?.name;
+                            if (rightLineSet.has(`${rightFirstIndex}_${rightSecondIndex}`) || leftLineSet.has(leftSecondIndex)) {
+                                return;
+                            }
+                            if (this.checkConditions({
+                                leftName,
+                                rightName,
+                                leftTypeAnnotation,
+                                rightTypeAnnotation: rightMember.__TypeAnnotation,
+                            })) {
+                                const leftIndex = [0, leftSecondIndex];
+                                const rightIndex = [rightFirstIndex, rightSecondIndex];
+                                const Line = new AssignmentLine({ leftIndex, rightIndex });
+                                lineArr.push(Line);
+                                leftLineSet.add(leftSecondIndex);
+                                rightLineSet.add(`${rightFirstIndex}_${rightSecondIndex}`);
+                            }
+                        });
+                    }
+                    else if (this.checkConditions({
+                        leftName,
+                        rightName: expression.name,
+                        leftTypeAnnotation,
+                        rightTypeAnnotation: expression.__TypeAnnotation,
+                    })) {
+                        if (rightLineSet.has(`${rightFirstIndex}`)) {
+                            return;
+                        }
                         const Line = new AssignmentLine({
                             leftIndex: [0, leftSecondIndex],
                             rightIndex: [rightFirstIndex],
                         });
                         lineArr.push(Line);
                         leftLineSet.add(leftSecondIndex);
-                        return;
+                        rightLineSet.add(`${rightFirstIndex}`);
                     }
-                    members.forEach((rightMember, rightSecondIndex) => {
-                        const rightValue = rightMember.getValue();
-                        const rightName = rightMember.property?.name;
-                        if (rightLineSet.has(rightSecondIndex) || leftLineSet.has(leftSecondIndex))
-                            return;
-                        if (leftName === rightName && leftValue.split('.').length === rightValue.split('.').length) {
-                            const rightTypeAnnotation = rightMember.__TypeAnnotation;
-                            if (leftTypeAnnotation.typeName !== rightTypeAnnotation.typeName)
-                                return;
-                            const leftIndex = [0, leftSecondIndex];
-                            const rightIndex = [rightFirstIndex, rightSecondIndex];
-                            const Line = new AssignmentLine({ leftIndex, rightIndex });
-                            lineArr.push(Line);
-                            leftLineSet.add(leftSecondIndex);
-                        }
-                    });
                 });
             });
             lineArr.length && this.setAssignmentLines([...this.assignmentLines, ...lineArr]);
             this.app.emit('collect:end');
         };
-        let count = 0;
-        const typeAnnotationEnd = () => {
-            const l = this.left.members.every((item) => item.__isCorrectTypeAnnotation);
-            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
-            count++;
-            if (l && r) {
-                autoConnection();
-            }
-            else if (count <= 10) {
-                setTimeout(() => {
-                    typeAnnotationEnd();
-                }, 100);
-            }
-        };
-        typeAnnotationEnd();
+        // 跟类型相关的才需要等待
+        if ([
+            MatchingStrategies.BY_TYPE,
+            MatchingStrategies.BY_NAME_AND_TYPE,
+        ].includes(this.matchingStrategy)) {
+            let count = 0;
+            const typeAnnotationEnd = () => {
+                const l = this.left.members.every((item) => item.__isCorrectTypeAnnotation);
+                const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
+                count++;
+                if (l && r) {
+                    autoConnection();
+                }
+                else if (count <= 10) {
+                    setTimeout(() => {
+                        typeAnnotationEnd();
+                    }, 100);
+                }
+            };
+            typeAnnotationEnd();
+        }
+        else {
+            autoConnection();
+        }
     }
     connection(leftItem, rightItem, rightToLeft) {
         let newLeftIndex = [0];
@@ -506,19 +784,104 @@ let BatchAssignment = class BatchAssignment extends LogicItem__1.default {
             });
         }
     }
-    changeMembers(oldNode, members, keepMembers, expression) {
+    async changeMembers(oldNode, members, expression) {
+        // 关闭定时
+        this.app._noTimer = true;
         this.app.emit('collect:start', {
             actionMsg: '批量赋值修改变量',
         });
-        const selectMember = oldNode.parentNode;
-        const autoConnectionIndex = this.rights.findIndex((right) => right === selectMember);
-        const newSelectMember = { ...selectMember?.toJSON?.(), expression, members };
+        const oldSelectMember = oldNode.parentNode;
+        // 之前的结构属性
+        const keepPropertyMap = new Map();
+        oldSelectMember.members.forEach((member) => {
+            if (asserts.isMemberExpression(member)) {
+                const typeAnnotation = member?.__TypeAnnotation || member?.typeAnnotation;
+                const lines = this.findlines(member, oldSelectMember);
+                keepPropertyMap.set(member?.completePropertyName, {
+                    member,
+                    lines,
+                    sortedTypeKey: typeAnnotation?.sortedTypeKey,
+                });
+            }
+        });
+        const targetRightIndex = this.rights.findIndex((right) => right === oldSelectMember);
+        const newSelectMemberJson = {
+            ...oldSelectMember?.toJSON?.(),
+            expression,
+            members,
+        };
         let newLines = [];
+        if (oldSelectMember.parentKey === 'left') {
+            this.update({
+                left: newSelectMemberJson,
+                assignmentLines: newLines,
+            });
+        }
+        else {
+            newLines = this.assignmentLines.filter(({ rightIndex, }) => {
+                return (rightIndex[0] !== targetRightIndex) || (rightIndex?.length === 1);
+            });
+            this.update({
+                rights: [
+                    ...this.rights.slice(0, targetRightIndex),
+                    newSelectMemberJson,
+                    ...this.rights.slice(targetRightIndex + 1, this.rights.length),
+                ],
+                assignmentLines: newLines,
+            });
+        }
+        // 触发ts类型标注
+        this.app.naslServer?.embeddedTSEmitter.emit('change', {
+            value: [
+                {
+                    originEvent: {
+                        action: 'update',
+                        target: this,
+                    },
+                },
+            ],
+        });
+        // 表达式的类型
+        await expression?.getCurrentTypeAnnotation(30000);
+        const propertyMap = new Map();
+        if (asserts.isIdentifier(expression)) {
+            const { namespace, name } = expression;
+            const completeList = [];
+            if (namespace) {
+                completeList.push(namespace);
+            }
+            completeList.push(name);
+            const completeName = completeList.join('.');
+            const count = propertyMap.size;
+            // 获取类型注解并提取其结构
+            const typeAnnotation = expression?.__TypeAnnotation || expression?.typeAnnotation;
+            // 将完整属性名添加到属性映射表中
+            propertyMap.set(completeName, {
+                index: count,
+                typeKey: typeAnnotation?.typeKey,
+            });
+            let depth = 0;
+            typeAnnotation?.collectPropertyMap(this.app, completeName, propertyMap, depth);
+        }
+        if (propertyMap.size) {
+            members.sort((a, b) => {
+                return (propertyMap.get(a.completeName)?.index - propertyMap.get(b.completeName)?.index);
+            });
+        }
+        const reservedLeftIndex = [];
+        const reservedRightIndex = [];
         // 修改连线
-        if (selectMember.parentKey === 'left') {
+        if (oldSelectMember.parentKey === 'left') {
+            this.left.update({
+                members,
+            });
             members.forEach((item, index) => {
-                if (keepMembers?.has(item.completeName)) {
-                    const lines = this.findlines(item, selectMember);
+                const oldPropertyInfo = keepPropertyMap.get(item?.completePropertyName);
+                const { sortedTypeKey } = oldPropertyInfo || {};
+                const typeAnnotation = item?.__TypeAnnotation || item?.typeAnnotation;
+                if (sortedTypeKey === typeAnnotation?.sortedTypeKey) {
+                    reservedLeftIndex.push(index);
+                    const { lines } = oldPropertyInfo || {};
                     lines.forEach((line) => {
                         const newLine = { ...line?.toJSON(), leftIndex: [line.leftIndex[0], index] };
                         newLines.push(newLine);
@@ -527,15 +890,20 @@ let BatchAssignment = class BatchAssignment extends LogicItem__1.default {
             });
             this.update({
                 assignmentLines: newLines,
-                left: newSelectMember,
             });
         }
         else {
-            const splitIndex = this.rights.findIndex((right) => selectMember === right);
-            newLines = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] !== splitIndex);
+            const newSelectMember = this.rights.find((right, index) => index === targetRightIndex);
+            newSelectMember.update({
+                members,
+            });
             members.forEach((item, index) => {
-                if (keepMembers?.has(item.completeName)) {
-                    const lines = this.findlines(item, selectMember);
+                const oldPropertyInfo = keepPropertyMap.get(item?.completePropertyName);
+                const { sortedTypeKey } = oldPropertyInfo || {};
+                const typeAnnotation = item?.__TypeAnnotation || item?.typeAnnotation;
+                if (sortedTypeKey === typeAnnotation?.sortedTypeKey) {
+                    reservedRightIndex.push(`${targetRightIndex}_${index}`);
+                    const { lines } = oldPropertyInfo || {};
                     lines.forEach((line) => {
                         const newLine = { ...line?.toJSON(), rightIndex: [line.rightIndex[0], index] };
                         newLines.push(newLine);
@@ -544,14 +912,13 @@ let BatchAssignment = class BatchAssignment extends LogicItem__1.default {
             });
             this.update({
                 assignmentLines: newLines,
-                rights: [
-                    ...this.rights.slice(0, splitIndex),
-                    newSelectMember,
-                    ...this.rights.slice(splitIndex + 1, this.rights.length),
-                ],
             });
         }
-        this.autoConnection && this.batchAutoConnection(autoConnectionIndex);
+        this.autoConnection && this.batchAutoConnection({
+            targetRightIndex,
+            reservedLeftIndex,
+            reservedRightIndex,
+        });
         this.app.emit('collect:end');
     }
     findMember(arrIndex, place) {