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

package/out/concepts/NewComposite__.js

@@ -37,6 +37,13 @@ exports.NewComposite = void 0;
 const utils_1 = require("../utils");
 const nasl_translator_1 = require("@lcap/nasl-translator");
 const quick_info_1 = require("./utils/quick-info");
+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"));
@@ -85,6 +92,8 @@ let NewComposite = class NewComposite extends LogicItem__1.default {
          * 自动连线
          */
         this.autoConnection = true;
+        // 匹配策略
+        this.matchingStrategy = MatchingStrategies.BY_TOP_DOWN;
         super.subConstructor(source);
     }
     static from(source, parentNode, parentKey) {
@@ -384,11 +393,84 @@ let NewComposite = class NewComposite extends LogicItem__1.default {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    /**
+     * 删除左边项
+     * @param property
+     */
+    deleteProperty(property) {
+        let index = -1;
+        const properties = this.properties.filter((p, i) => {
+            if (p === property) {
+                index = i;
+                return false;
+            }
+            return true;
+        });
+        const newLines = [];
+        this.assignmentLines.forEach((line) => {
+            const targetIndex = line?.leftIndex;
+            if (targetIndex[1] < index) {
+                newLines.push(line);
+            }
+            else if (targetIndex[1] > index) {
+                const newLine = {
+                    ...line?.toJSON(),
+                    leftIndex: [targetIndex[0], targetIndex[1] - 1],
+                };
+                newLines.push(newLine);
+            }
+        });
+        this.app.emit('collect:start', {
+            actionMsg: '删除左边项',
+        });
+        this.update({
+            properties,
+            assignmentLines: newLines,
+        });
+        this.app.emit('collect:end');
+    }
     get lines() {
         return this.assignmentLines.length;
     }
-    newConnection(addRightIndex) {
+    checkConditions({ isAnnotation, 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 isAnnotation || rightTypeAnnotation?.sortedTypeKey === leftTypeAnnotation.sortedTypeKey;
+            });
+        }
+        if ([
+            MatchingStrategies.BY_TOP_DOWN,
+        ].includes(this.matchingStrategy)) {
+            conditions.push(() => {
+                return true;
+            });
+        }
+        return conditions.every(condition => condition());
+    }
+    /**
+     * 自动连线算法
+     * @param param0
+     */
+    batchAutoConnection({ targetRightIndex, reservedRightIndex, reservedLeftIndex, }) {
         const leftLineSet = new Set();
+        if (Array.isArray(reservedLeftIndex)) {
+            reservedLeftIndex.forEach((index) => {
+                leftLineSet.add(index);
+            });
+        }
         const lineArr = [];
         const AssignmentLine = (0, decorators_1.getConceptConstructor)('AssignmentLine');
         // 系统属性不可自动连线
@@ -399,75 +481,135 @@ let NewComposite = class NewComposite extends LogicItem__1.default {
                 leftLineSet.add(Number(line.leftIndex[1]));
         });
         const autoConnection = () => {
-            const isAnnotation = this.typeAnnotation.typeKind === 'anonymousStructure';
+            // 匿名数据结构
+            const isAnnotation = this.typeAnnotation?.typeKind === 'anonymousStructure';
             this.app.emit('collect:start', {
                 actionMsg: '自动连线',
             });
-            this.properties.forEach((property, leftSecondIndex) => {
-                const leftName = property.name;
-                const leftTypeAnnotation = !isAnnotation && property.__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.properties.forEach((property, leftSecondIndex) => {
+                const leftName = property.name;
+                const leftTypeAnnotation = !isAnnotation && property.__TypeAnnotation;
+                targetRights.forEach(({ right: targetRight, index: rightFirstIndex, }) => {
+                    // 已经有连线的不需要自动连线
+                    if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName)) {
+                        return;
                     }
-                    if (leftName === expression.name &&
-                        (isAnnotation || 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 (this.checkConditions({
+                                isAnnotation,
+                                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({
+                        isAnnotation,
+                        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 rightName = rightMember.property.name;
-                        if (rightLineSet.has(rightSecondIndex) || leftLineSet.has(leftSecondIndex))
-                            return;
-                        if (leftName === rightName) {
-                            const rightTypeAnnotation = rightMember.__TypeAnnotation;
-                            if (!isAnnotation && 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.properties.every((item) => item.__isCorrectTypeAnnotation);
-            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
-            count++;
-            if (r && l) {
-                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.properties.every((item) => item.__isCorrectTypeAnnotation);
+                const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
+                count++;
+                if (r && l) {
+                    autoConnection();
+                }
+                else if (count <= 10) {
+                    setTimeout(() => {
+                        typeAnnotationEnd();
+                    }, 100);
+                }
+            };
+            typeAnnotationEnd();
+        }
+        else {
+            autoConnection();
+        }
     }
     connection(leftItem, rightItem, rightToLeft) {
         let newLeftIndex = [0];
@@ -543,14 +685,207 @@ let NewComposite = class NewComposite extends LogicItem__1.default {
             });
         }
     }
-    changeMembers(oldNode, members, keepMembers, expression) {
+    // 替换变量
+    async replaceIdentifier(oldNode, expression, members) {
+        // 关闭定时
+        this.app._noTimer = true;
+        this.app.emit('collect:start', {
+            actionMsg: '替换变量',
+        });
+        // 被替换的第一层属性
+        const oldSelectMember = oldNode.parentNode;
+        const firstRightIndex = this.rights.findIndex((right) => {
+            return oldSelectMember === right;
+        });
+        const newSelectMember = {
+            ...(oldSelectMember?.toJSON?.() ?? oldSelectMember),
+            expression,
+            members: [],
+        };
+        // 待定的连线（保留的属性的连线也要保留）
+        const pendingLinesMap = new Map();
+        const 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({
+            assignmentLines: newLines,
+            rights: [
+                ...this.rights.slice(0, firstRightIndex),
+                newSelectMember,
+                ...this.rights.slice(firstRightIndex + 1, this.rights.length),
+            ],
+        });
+        // 触发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 reservedRightIndex = [];
+        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);
+                    });
+                }
+            }
+        });
+        const right = this.rights[firstRightIndex];
+        const MemberExpression = (0, decorators_1.getConceptConstructor)('MemberExpression');
+        right.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,
+        });
+        this.app.emit('collect:end');
+    }
+    changeLeft({ typeAnnotation, batchExpression, }) {
+        const properties = [];
+        // 新的实体/数据结构下，与原实体/数据结构的属性一致时，保持原有连线状态； -一致即名称和类型均一致
+        const newLines = [];
+        const reservedLeftIndex = [];
+        let autoConnection = this.autoConnection;
+        if (typeAnnotation) {
+            const propertyMap = typeAnnotation.collectPropertyMap(this.app);
+            batchExpression.sort((a, b) => {
+                return (propertyMap.get(a.completeName)?.index - propertyMap.get(b.completeName)?.index);
+            });
+            // 之前的结构属性
+            const keepPropertyMap = new Map();
+            this.properties.forEach((property) => {
+                const typeAnnotation = property?.__TypeAnnotation || property?.typeAnnotation;
+                const lines = this.findlines(property, this);
+                keepPropertyMap.set(property?.completeName, {
+                    property,
+                    lines,
+                    sortedTypeKey: typeAnnotation?.sortedTypeKey,
+                });
+            });
+            // 需要清除引用，否则nodePath会引用到旧的member节点
+            batchExpression.map(({ expression }, index) => {
+                const Identifier = (0, decorators_1.getConceptConstructor)('Identifier');
+                const ident = new Identifier({
+                    name: expression.name,
+                });
+                properties.push(ident);
+                const oldPropertyInfo = keepPropertyMap.get(expression.name);
+                if (oldPropertyInfo) {
+                    reservedLeftIndex.push(index);
+                    const { lines } = oldPropertyInfo || {};
+                    lines.forEach((line) => {
+                        const newLine = {
+                            ...line?.toJSON(),
+                            leftIndex: [line.leftIndex[0], index],
+                        };
+                        newLines.push(newLine);
+                    });
+                }
+            });
+        }
+        else {
+            autoConnection = false;
+        }
+        this.update({
+            typeAnnotation,
+            properties,
+            assignmentLines: newLines,
+        });
+        autoConnection && this.batchAutoConnection({
+            targetRightIndex: -1,
+            reservedLeftIndex,
+        });
+    }
+    async changeMembers(oldNode, members, expression) {
+        // 关闭定时
+        this.app._noTimer = true;
         this.app.emit('collect:start', {
             actionMsg: 'New初始赋值修改变量',
         });
-        const selectMember = oldNode.parentNode;
-        const autoConnectionIndex = this.rights.findIndex((right) => right === selectMember);
-        const newSelectMember = { ...(selectMember?.toJSON?.() ?? selectMember), expression, members };
-        const splitIndex = this.rights.findIndex((right) => selectMember === right);
+        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);
         let keepLines = false;
         if (this?.concept === 'NewComposite' &&
             this?.typeAnnotation?.typeKind === 'anonymousStructure' &&
@@ -559,28 +894,85 @@ let NewComposite = class NewComposite extends LogicItem__1.default {
             if (tempNode && tempNode?.calleeName === 'ListSort')
                 keepLines = true;
         }
-        const newLines = keepLines ? this.assignmentLines : this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] !== splitIndex);
-        let oldLines = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] === splitIndex);
+        const newLines = keepLines ? this.assignmentLines : this.assignmentLines.filter(({ rightIndex, }) => {
+            return (rightIndex[0] !== targetRightIndex) || (rightIndex?.length === 1);
+        });
+        this.update({
+            assignmentLines: newLines,
+            rights: [
+                ...this.rights.slice(0, targetRightIndex),
+                {
+                    ...(oldSelectMember?.toJSON?.() ?? oldSelectMember),
+                    expression,
+                    members,
+                },
+                ...this.rights.slice(targetRightIndex + 1, this.rights.length),
+            ],
+        });
+        // 触发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 reservedRightIndex = [];
         // 右侧变量改变后，修改连线
         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?.() ?? line), rightIndex: [line.rightIndex[0], index] };
+                    const newLine = { ...line?.toJSON(), rightIndex: [line.rightIndex[0], index] };
                     newLines.push(newLine);
-                    oldLines = oldLines.filter(({ leftIndex }) => leftIndex[1] !== line.leftIndex[1]);
                 });
             }
         });
+        const newSelectMember = this.rights.find((right, index) => index === targetRightIndex);
+        newSelectMember.update({
+            members,
+        });
         this.update({
             assignmentLines: newLines,
-            rights: [
-                ...this.rights.slice(0, splitIndex),
-                newSelectMember,
-                ...this.rights.slice(splitIndex + 1, this.rights.length),
-            ],
         });
-        this.autoConnection && this.newConnection(autoConnectionIndex);
+        this.autoConnection && this.batchAutoConnection({
+            targetRightIndex,
+            reservedRightIndex,
+        });
         this.app.emit('collect:end');
     }
     findlines(member, selectMember) {
@@ -1187,12 +1579,18 @@ let NewComposite = class NewComposite extends LogicItem__1.default {
         this.app.emit('collect:start', {
             actionMsg: '添加匿名数据结构属性',
         });
+        const reservedLeftIndex = Array.from({
+            length: this.properties.length,
+        }, (v, i) => i);
         const node = this.addIdentifier({ name: this.getIdentifierUniqueName(newName) });
         const struct = StructureProperty.from({
             name: node.name,
             typeAnnotation: newType,
         });
         this.typeAnnotation.addStructureProperty(struct);
+        this.autoConnection && this.batchAutoConnection({
+            reservedLeftIndex,
+        });
         this.app.emit('collect:end');
     }
     __deleteIdentifier(property) {