@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/out/server/extendBaseNode.js

@@ -1,544 +1,575 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const concepts_1 = require("../concepts");
-const common_1 = require("../common");
-const utils_1 = require("../automate/engine/utils");
-const sentry_1 = require("../sentry");
-concepts_1.BaseNode.prototype.findReadOnlyLogicUsage = function () {
-    let targetNode;
-    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
-        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0];
-            if (this.concept === 'Logic') {
-                if (logic instanceof concepts_1.Logic)
-                    if (logic.calleewholeKey === this.calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
-            else {
-                if (logic instanceof concepts_1.Logic)
-                    if (logic.calleewholeKey === this.parentNode.calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
-        }
-    }
-    else if (this.parentNode.concept === 'Module') {
-        // 父级是模块的还是用它本身去查找引用
-        targetNode = this;
-    }
-    else {
-        const sourceMap = this.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0];
-            if (logic.calleewholeKey && logic.calleewholeKey === this.calleewholeKey) {
-                targetNode = logic;
-                break;
-            }
-        }
-        if (!targetNode)
-            for (const item of sourceMap) {
-                const logic = item[0];
-                if (logic.getNamespace && logic.getNamespace() === this.getNamespace()) {
-                    targetNode = logic;
-                    break;
-                }
-            }
-    }
-    try {
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        return naslServer.findReferences(targetNode || this);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-// 查找引用
-concepts_1.BaseNode.prototype.findUsage = function findUsage() {
-    try {
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        return naslServer.findReferences(this);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-// 通过当前节点，查找被引用的节点
-concepts_1.BaseNode.prototype.nodeFindRefNodes = function nodeFindRefNodes() {
-    try {
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        return naslServer.nodeFindRefNodes(this);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-concepts_1.BaseNode.prototype.changeName = async function changeName(newValue, updateAll = false) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        const refsList = await naslServer._isHaveRef(this);
-        // 是不是有引用有的话，就返回
-        /**
-         * @param this 当前重命名的节点
-         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
-         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
-         * @returns 找到的引用
-         */
-        const res = naslServer._renamePrepare(this, refsList, newValue);
-        // 针对外部接口的鉴权方式，sourceMap 定位仅仅 定位到 CallAuthInterfacer
-        // 因此这里需要保存this来做上下文判断
-        const _this = this;
-        if (res.length <= 1) {
-            if (this.concept === 'enumItem') {
-                this.setValue(newValue);
-            }
-            else
-                this.setName(newValue);
-        }
-        else {
-            const callback = (value) => {
-                if (value) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '重命名并更新引用',
-                    });
-                    res.forEach((item) => {
-                        const itemNode = item.node;
-                        // MsgTriggerLauncher 比较特殊，实际更名的应该为成员表达式
-                        if (itemNode instanceof concepts_1.MsgTriggerLauncher) {
-                            itemNode.callBackLogic.setName(newValue);
-                            return;
-                        }
-                        if (item.newValue) {
-                            // 如果有指定的修改方法，就用那个，没有就修改名字
-                            if (item.setTypeMethods) {
-                                const func = itemNode && itemNode[item.setTypeMethods];
-                                typeof func === 'function' && itemNode[item.setTypeMethods](item.newValue);
-                            }
-                            else {
-                                itemNode.setName?.(item.newValue);
-                            }
-                        }
-                        else {
-                            if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
-                                const { calleewholeKey } = itemNode;
-                                const targetItf = (0, utils_1.getNodeByNodeCallee)(App, calleewholeKey);
-                                targetItf.setAuthLogic(newValue);
-                                // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
-                                itemNode.update({});
-                            }
-                            else {
-                                item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                }
-                else {
-                    this.setName(newValue);
-                }
-            };
-            const confirmParms = {
-                actionType: 'rename',
-                node: this,
-                newValue,
-            };
-            /**
-             * nasl和vue的通信，回退，要触发vue的watch。
-             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
-             * 先修改之
-             */
-            const closeCallBack = () => {
-                if (this.concept === 'EnumItem') {
-                    const oldValue = this.value;
-                    this.value = oldValue + ' ';
-                    setTimeout(() => {
-                        this.value = oldValue;
-                    }, 0);
-                }
-                else {
-                    const oldValue = this.name;
-                    this.name = oldValue + ' ';
-                    setTimeout(() => {
-                        this.name = oldValue;
-                    }, 0);
-                }
-            };
-            updateAll ? callback(true) : (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback, closeCallBack);
-            return;
-        }
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/** 删除连接器 */
-function delConnection(node) {
-    const app = node.rootNode;
-    app.emit('collect:start', {
-        actionMsg: '删除连接器',
-    });
-    if (node.connector?.connectorKind === 'kafka') {
-        // 删除相关的触发器
-        app.triggerLaunchers.forEach((launcher) => {
-            if (launcher.calleeConnectionName === node.name) {
-                launcher.delete();
-            }
-        });
-    }
-    node.delete();
-    app.emit('collect:end');
-}
-/**
- * 准备删除
- */
-concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete(cb) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        const node = this;
-        let refsList = await naslServer._isHaveRef(node);
-        // 删除的时候过滤一把组件删除提示
-        refsList = refsList.filter((item) => 
-        // 因为ui组件本身会多渲染一次,就先过滤一个
-        !item.lineText.includes(': nasl.ui.'));
-        // delete的弹框展示
-        const confirmParms = {
-            actionType: 'delete',
-            tipFlag: false,
-            node,
-            icon: 'warning',
-        };
-        let callback = null;
-        if (refsList.length <= 1 || (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.Logic && refsList.length <= 2)) {
-            // 平台类型直接删除然后return
-            if (node instanceof concepts_1.ViewElement) {
-                this.delete();
-                return;
-            }
-            callback = () => {
-                // 外部接口删除时，只需要删除自己，不需要删除数据结构
-                if (node instanceof concepts_1.Interface && node.parentNode.concept === 'App') {
-                    this.delete();
-                    return;
-                }
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
-                    this.deleteLogincAndModule();
-                }
-                else if (node instanceof concepts_1.Connection) {
-                    delConnection(node);
-                    if (cb) {
-                        cb();
-                    }
-                }
-                else {
-                    this.delete();
-                }
-            };
-        }
-        else {
-            // 如果有依赖就有一个查找引用提示
-            confirmParms.tipFlag = true;
-            const node = this;
-            // 删除页面或者流程
-            if (node instanceof concepts_1.View || node instanceof concepts_1.Process || node instanceof concepts_1.Frontend) {
-                /**
-                 * 查找这个页面是不是有依赖
-                 */
-                let viewPath = this.getEmbeddedFilePath();
-                viewPath = viewPath.slice(0, viewPath.length - 3);
-                const find = refsList.find((record) => !record.file.includes(viewPath));
-                // 如果没有别的文件的依赖，就直接delete
-                if (!find) {
-                    if (node instanceof concepts_1.Process) {
-                        const App = this.rootNode;
-                        App.emit('collect:start', {
-                            actionMsg: `删除流程${node.name}`,
-                        });
-                        await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
-                        this.delete();
-                        App.emit('collect:end');
-                    }
-                    else {
-                        this.delete();
-                        if (node instanceof concepts_1.Frontend) {
-                            return;
-                        }
-                    }
-                    return;
-                }
-                else {
-                    if (node instanceof concepts_1.Frontend) {
-                        let viewPath = this.getEmbeddedFilePath();
-                        viewPath = viewPath.slice(0, viewPath.length - 3);
-                        const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
-                        // 删除流程节点绑定的该端的页面跳转
-                        const result = refsTempList
-                            .map((record) => {
-                            const fileNode = naslServer.file2NodeMap.get(record.file);
-                            if (fileNode) {
-                                const minRange = naslServer._findMinRange(record, fileNode);
-                                if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
-                                    return minRange.node.parentNode;
-                                }
-                            }
-                            return null;
-                        })
-                            .filter((record) => !!record);
-                        const App = this.rootNode;
-                        App.emit('collect:start', {
-                            actionMsg: `删除端${node.name}`,
-                        });
-                        await Promise.all(result.map((ele) => ele.delete()));
-                        this.delete();
-                        App.emit('collect:end');
-                        return;
-                    }
-                }
-            }
-            callback = async () => {
-                // removeParam
-                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
-                if (node instanceof concepts_1.Param) {
-                    const App = this.rootNode;
-                    const parentNode = this.parentNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除参数',
-                    });
-                    const Index = node.getIndexOfParent();
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            /**
-                             * 调用方是 调用逻辑或者跳转页面， 去删除对应位置的内容
-                             * 如果是跳转页面，因为流程下的特殊翻译，需要过滤下 非页面下的参数修改，查找到页面跳转
-                             */
-                            if (minRange.node instanceof concepts_1.CallLogic ||
-                                (node.parentNode instanceof concepts_1.View && minRange.node instanceof concepts_1.Destination) ||
-                                minRange.node instanceof concepts_1.CallAuthInterface) {
-                                minRange.node.deleteCalleeArg(Index);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除logic节点，如果有对应的interface要一起删除
-                if (node instanceof concepts_1.Logic) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除逻辑并删除导出的接口',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.Interface) {
-                                minRange.node.delete();
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除权限节点
-                if (node instanceof concepts_1.Role) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除权限',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.ViewElement) {
-                                // oldName旧的节点存的值
-                                // newValue用户输入值
-                                // node.bindRoles 存的
-                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
-                                const newBindRoles = str.split(',').filter((item) => !!item);
-                                minRange.node.setBindRoles(newBindRoles);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
-                if (node instanceof concepts_1.View) {
-                    this.delete();
-                }
-                if (node instanceof concepts_1.Process) {
-                    const App = this.rootNode;
-                    App.emit('collect:start', {
-                        actionMsg: `删除流程${node.name}`,
-                    });
-                    await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
-                    this.delete();
-                    App.emit('collect:end');
-                }
-                // 外部接口删除时，只需要删除自己，不需要删除数据结构
-                if (node instanceof concepts_1.Interface && node.parentNode.concept === 'App') {
-                    this.delete();
-                    return;
-                }
-                if (node instanceof concepts_1.Connection) {
-                    delConnection(node);
-                    if (cb) {
-                        cb();
-                    }
-                    return;
-                }
-                // 其余的都直接调用删除
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
-                    this.deleteLogincAndModule();
-                }
-                else {
-                    this.delete();
-                }
-            };
-        }
-        (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/**
- * 如果添加需要触发查找引用并且在之后，对内容产生影响
- */
-concepts_1.BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd = true) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        const refsList = await naslServer._isHaveRef(this);
-        return naslServer._addParamsPrepare(this, refsList, needAdd);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/**
- * 在原型上增加方法来调用
- */
-concepts_1.BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation(outTime) {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const app = this.getAncestor('App');
-        const naslServer = app.naslServer;
-        return naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-function newNode(node, parentNode, needNewStructure) {
-    if (needNewStructure && node?.toJSON) {
-        return concepts_1.BaseNode.from(node.toJSON(), parentNode, '');
-    }
-    return node;
-}
-/**
- * 获取下一级变量
- */
-concepts_1.BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation, needNewStructure = false) {
-    try {
-        const typeAnnotation = newTypeAnnotation || this.typeAnnotation || this.__TypeAnnotation;
-        const { typeName, typeKind, typeNamespace, typeArguments, properties: typeProperties } = typeAnnotation;
-        const parentNode = this;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth' || typeNamespace === 'nasl.http') {
-                const node = newNode((0, utils_1.getNaslNodeByNodeCallee)(typeNamespace, typeName), parentNode, needNewStructure);
-                const properties = node?.properties || [];
-                completionChildren = properties;
-            }
-            else if (typeNamespace.endsWith('.enums')) {
-                completionChildren = [];
-            }
-            else {
-                let app;
-                if (this.concept === 'App') {
-                    app = this;
-                }
-                else {
-                    app = this.rootNode || typeAnnotation.app;
-                }
-                const node = newNode((0, utils_1.getNodeByNodeCallee)(app, typeNamespace + '.' + typeName), parentNode, needNewStructure);
-                const properties = node?.properties || [];
-                completionChildren = properties;
-            }
-        }
-        else if (typeKind === 'generic') {
-            const node = newNode((0, utils_1.getNaslNodeByNodeCallee)(typeNamespace, typeName), parentNode, needNewStructure);
-            const properties = (node?.properties && [...node?.properties]) || [];
-            for (let i = 0; i < properties.length; i++) {
-                const item = properties[i];
-                if (item?.typeAnnotation?.typeKind === 'typeParam') {
-                    if (item.name === 'columnItem' && typeArguments[1]) {
-                        item.typeAnnotation = concepts_1.TypeAnnotation.from(typeArguments[1].toJSON(), node, 'typeAnnotation');
-                    }
-                    else if (typeArguments[0]) {
-                        item.typeAnnotation = concepts_1.TypeAnnotation.from(typeArguments[0].toJSON(), node, 'typeAnnotation');
-                    }
-                    properties[i];
-                }
-            }
-            completionChildren = properties;
-        }
-        else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
-            const node = newNode((0, utils_1.getNaslNodeByNodeCallee)(typeNamespace, typeName), parentNode, needNewStructure);
-            const properties = (node?.properties && [...node?.properties]) || [];
-            completionChildren = properties;
-        }
-        else if (typeKind === 'anonymousStructure' && typeProperties?.length) {
-            const node = newNode(typeAnnotation, parentNode, needNewStructure);
-            const properties = (node?.properties && [...node?.properties]) || [];
-            completionChildren = properties;
-        }
-        return completionChildren;
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-(0, sentry_1.extendSentryMonitorNaslNode)(concepts_1.BaseNode);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const concepts_1 = require("../concepts");
+const common_1 = require("../common");
+const utils_1 = require("../automate/engine/utils");
+const sentry_1 = require("../sentry");
+concepts_1.BaseNode.prototype.findReadOnlyLogicUsage = function () {
+    let targetNode;
+    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
+        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
+        for (const item of sourceMap) {
+            const logic = item[0];
+            if (this.concept === 'Logic') {
+                if (logic instanceof concepts_1.Logic)
+                    if (logic.calleewholeKey === this.calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            }
+            else {
+                if (logic instanceof concepts_1.Logic)
+                    if (logic.calleewholeKey === this.parentNode.calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            }
+        }
+    }
+    else if (this.parentNode.concept === 'Module') {
+        // 父级是模块的还是用它本身去查找引用
+        targetNode = this;
+    }
+    else {
+        const sourceMap = this.parentNode.sourceMap;
+        for (const item of sourceMap) {
+            const logic = item[0];
+            if (logic.calleewholeKey && logic.calleewholeKey === this.calleewholeKey) {
+                targetNode = logic;
+                break;
+            }
+        }
+        if (!targetNode)
+            for (const item of sourceMap) {
+                const logic = item[0];
+                if (logic.getNamespace && logic.getNamespace() === this.getNamespace()) {
+                    targetNode = logic;
+                    break;
+                }
+            }
+    }
+    try {
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        return naslServer.findReferences(targetNode || this);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+// 查找引用
+concepts_1.BaseNode.prototype.findUsage = function findUsage() {
+    try {
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        return naslServer.findReferences(this);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+// 通过当前节点，查找被引用的节点
+concepts_1.BaseNode.prototype.nodeFindRefNodes = function nodeFindRefNodes() {
+    try {
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        return naslServer.nodeFindRefNodes(this);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+concepts_1.BaseNode.prototype.changeName = async function changeName(newValue, updateAll = false) {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        const refsList = await naslServer._isHaveRef(this);
+        // 是不是有引用有的话，就返回
+        /**
+         * @param this 当前重命名的节点
+         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+         * @returns 找到的引用
+         */
+        const res = naslServer._renamePrepare(this, refsList, newValue);
+        // 针对外部接口的鉴权方式，sourceMap 定位仅仅 定位到 CallAuthInterfacer
+        // 因此这里需要保存this来做上下文判断
+        const _this = this;
+        if (res.length <= 1) {
+            if (this.concept === 'enumItem') {
+                this.setValue(newValue);
+            }
+            else if (['Process', 'ProcessElement'].includes(this.concept)) {
+                const confirmParms = {
+                    actionType: 'rename',
+                    node: this,
+                    newValue,
+                    unReference: true,
+                    icon: 'warning',
+                };
+                if (this.concept === 'Process') {
+                    confirmParms.title = '重命名流程名称';
+                    confirmParms.process = true;
+                }
+                else if (this.concept === 'ProcessElement') {
+                    confirmParms.title = '修改节点名称';
+                    confirmParms.process = true;
+                }
+                const callback = () => {
+                    this.setName(newValue);
+                };
+                (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback);
+            }
+            else
+                this.setName(newValue);
+        }
+        else {
+            const callback = (value, toast) => {
+                if (value) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '重命名并更新引用',
+                    });
+                    res.forEach((item) => {
+                        const itemNode = item.node;
+                        // MsgTriggerLauncher 比较特殊，实际更名的应该为成员表达式
+                        if (itemNode instanceof concepts_1.MsgTriggerLauncher) {
+                            itemNode.callBackLogic.setName(newValue);
+                            return;
+                        }
+                        if (item.newValue) {
+                            // 如果有指定的修改方法，就用那个，没有就修改名字
+                            if (item.setTypeMethods) {
+                                const func = itemNode && itemNode[item.setTypeMethods];
+                                typeof func === 'function' && itemNode[item.setTypeMethods](item.newValue);
+                            }
+                            else {
+                                itemNode.setName?.(item.newValue);
+                            }
+                        }
+                        else {
+                            if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
+                                const { calleewholeKey } = itemNode;
+                                const targetItf = (0, utils_1.getNodeByNodeCallee)(App, calleewholeKey);
+                                targetItf.setAuthLogic(newValue);
+                                // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
+                                itemNode.update({});
+                            }
+                            else {
+                                item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    toast && toast();
+                }
+                else {
+                    this.setName(newValue);
+                }
+            };
+            const confirmParms = {
+                actionType: 'rename',
+                node: this,
+                newValue,
+                icon: 'warning',
+            };
+            if (this.concept === 'Process') {
+                confirmParms.title = '重命名流程名称';
+                confirmParms.process = true;
+            }
+            else if (this.concept === 'ProcessElement') {
+                confirmParms.title = '修改节点名称';
+                confirmParms.process = true;
+            }
+            /**
+             * nasl和vue的通信，回退，要触发vue的watch。
+             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
+             * 先修改之
+             */
+            const closeCallBack = () => {
+                if (this.concept === 'EnumItem') {
+                    const oldValue = this.value;
+                    this.value = oldValue + ' ';
+                    setTimeout(() => {
+                        this.value = oldValue;
+                    }, 0);
+                }
+                else {
+                    const oldValue = this.name;
+                    this.name = oldValue + ' ';
+                    setTimeout(() => {
+                        this.name = oldValue;
+                    }, 0);
+                }
+            };
+            updateAll ? callback(true) : (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback, closeCallBack);
+            return;
+        }
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+/** 删除连接器 */
+function delConnection(node) {
+    const app = node.rootNode;
+    app.emit('collect:start', {
+        actionMsg: '删除连接器',
+    });
+    if (node.connector?.connectorKind === 'kafka') {
+        // 删除相关的触发器
+        app.triggerLaunchers.forEach((launcher) => {
+            if (launcher.calleeConnectionName === node.name) {
+                launcher.delete();
+            }
+        });
+    }
+    node.delete();
+    app.emit('collect:end');
+}
+/**
+ * 准备删除
+ */
+concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete(cb) {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        const node = this;
+        let refsList = await naslServer._isHaveRef(node);
+        // 删除的时候过滤一把组件删除提示
+        refsList = refsList.filter((item) => 
+        // 因为ui组件本身会多渲染一次,就先过滤一个
+        !item.lineText.includes(': nasl.ui.'));
+        // delete的弹框展示
+        const confirmParms = {
+            actionType: 'delete',
+            tipFlag: false,
+            node,
+            icon: 'warning',
+        };
+        let callback = null;
+        if (refsList.length <= 1 || (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.Logic && refsList.length <= 2)) {
+            // 平台类型直接删除然后return
+            if (node instanceof concepts_1.ViewElement) {
+                this.delete();
+                return;
+            }
+            callback = () => {
+                // 外部接口删除时，只需要删除自己，不需要删除数据结构
+                if (node instanceof concepts_1.Interface && node.parentNode.concept === 'App') {
+                    this.delete();
+                    return;
+                }
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
+                    this.deleteLogincAndModule();
+                }
+                else if (node instanceof concepts_1.Connection) {
+                    delConnection(node);
+                    if (cb) {
+                        cb();
+                    }
+                }
+                else {
+                    this.delete();
+                }
+            };
+        }
+        else {
+            // 如果有依赖就有一个查找引用提示
+            confirmParms.tipFlag = true;
+            const node = this;
+            // 删除页面或者流程
+            if (node instanceof concepts_1.View || node instanceof concepts_1.Process || node instanceof concepts_1.Frontend) {
+                /**
+                 * 查找这个页面是不是有依赖
+                 */
+                let viewPath = this.getEmbeddedFilePath();
+                viewPath = viewPath.slice(0, viewPath.length - 3);
+                const find = refsList.find((record) => !record.file.includes(viewPath));
+                // 如果没有别的文件的依赖，就直接delete
+                if (!find) {
+                    if (node instanceof concepts_1.Process) {
+                        const App = this.rootNode;
+                        App.emit('collect:start', {
+                            actionMsg: `删除流程${node.name}`,
+                        });
+                        await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
+                        this.delete();
+                        App.emit('collect:end');
+                    }
+                    else {
+                        this.delete();
+                        if (node instanceof concepts_1.Frontend) {
+                            return;
+                        }
+                    }
+                    return;
+                }
+                else {
+                    if (node instanceof concepts_1.Frontend) {
+                        let viewPath = this.getEmbeddedFilePath();
+                        viewPath = viewPath.slice(0, viewPath.length - 3);
+                        const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
+                        // 删除流程节点绑定的该端的页面跳转
+                        const result = refsTempList
+                            .map((record) => {
+                            const fileNode = naslServer.file2NodeMap.get(record.file);
+                            if (fileNode) {
+                                const minRange = naslServer._findMinRange(record, fileNode);
+                                if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
+                                    return minRange.node.parentNode;
+                                }
+                            }
+                            return null;
+                        })
+                            .filter((record) => !!record);
+                        const App = this.rootNode;
+                        App.emit('collect:start', {
+                            actionMsg: `删除端${node.name}`,
+                        });
+                        await Promise.all(result.map((ele) => ele.delete()));
+                        this.delete();
+                        App.emit('collect:end');
+                        return;
+                    }
+                }
+            }
+            callback = async () => {
+                // removeParam
+                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
+                if (node instanceof concepts_1.Param) {
+                    const App = this.rootNode;
+                    const parentNode = this.parentNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除参数',
+                    });
+                    const Index = node.getIndexOfParent();
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange = naslServer._findMinRange(record, fileNode);
+                        if (minRange) {
+                            /**
+                             * 调用方是 调用逻辑或者跳转页面， 去删除对应位置的内容
+                             * 如果是跳转页面，因为流程下的特殊翻译，需要过滤下 非页面下的参数修改，查找到页面跳转
+                             */
+                            if (minRange.node instanceof concepts_1.CallLogic ||
+                                (node.parentNode instanceof concepts_1.View && minRange.node instanceof concepts_1.Destination) ||
+                                minRange.node instanceof concepts_1.CallAuthInterface) {
+                                minRange.node.deleteCalleeArg(Index);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+                // 删除logic节点，如果有对应的interface要一起删除
+                if (node instanceof concepts_1.Logic) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除逻辑并删除导出的接口',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange = naslServer._findMinRange(record, fileNode);
+                        if (minRange) {
+                            if (minRange.node instanceof concepts_1.Interface) {
+                                minRange.node.delete();
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+                // 删除权限节点
+                if (node instanceof concepts_1.Role) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除权限',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange = naslServer._findMinRange(record, fileNode);
+                        if (minRange) {
+                            if (minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.ViewElement) {
+                                // oldName旧的节点存的值
+                                // newValue用户输入值
+                                // node.bindRoles 存的
+                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
+                                const newBindRoles = str.split(',').filter((item) => !!item);
+                                minRange.node.setBindRoles(newBindRoles);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
+                if (node instanceof concepts_1.View) {
+                    this.delete();
+                }
+                if (node instanceof concepts_1.Process) {
+                    const App = this.rootNode;
+                    App.emit('collect:start', {
+                        actionMsg: `删除流程${node.name}`,
+                    });
+                    await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
+                    this.delete();
+                    App.emit('collect:end');
+                }
+                // 外部接口删除时，只需要删除自己，不需要删除数据结构
+                if (node instanceof concepts_1.Interface && node.parentNode.concept === 'App') {
+                    this.delete();
+                    return;
+                }
+                if (node instanceof concepts_1.Connection) {
+                    delConnection(node);
+                    if (cb) {
+                        cb();
+                    }
+                    return;
+                }
+                // 其余的都直接调用删除
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
+                    this.deleteLogincAndModule();
+                }
+                else {
+                    this.delete();
+                }
+            };
+        }
+        (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+/**
+ * 如果添加需要触发查找引用并且在之后，对内容产生影响
+ */
+concepts_1.BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd = true) {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        const refsList = await naslServer._isHaveRef(this);
+        return naslServer._addParamsPrepare(this, refsList, needAdd);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+/**
+ * 在原型上增加方法来调用
+ */
+concepts_1.BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation(outTime) {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const app = this.getAncestor('App');
+        const naslServer = app.naslServer;
+        return naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+function newNode(node, parentNode, needNewStructure) {
+    if (needNewStructure && node?.toJSON) {
+        return concepts_1.BaseNode.from(node.toJSON(), parentNode, '');
+    }
+    return node;
+}
+/**
+ * 获取下一级变量
+ */
+concepts_1.BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation, needNewStructure = false) {
+    try {
+        const typeAnnotation = newTypeAnnotation || this.typeAnnotation || this.__TypeAnnotation;
+        const { typeName, typeKind, typeNamespace, typeArguments, properties: typeProperties } = typeAnnotation;
+        const parentNode = this;
+        let completionChildren;
+        if (typeKind === 'reference') {
+            if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth' || typeNamespace === 'nasl.http') {
+                const node = newNode((0, utils_1.getNaslNodeByNodeCallee)(typeNamespace, typeName), parentNode, needNewStructure);
+                const properties = node?.properties || [];
+                completionChildren = properties;
+            }
+            else if (typeNamespace.endsWith('.enums')) {
+                completionChildren = [];
+            }
+            else {
+                let app;
+                if (this.concept === 'App') {
+                    app = this;
+                }
+                else {
+                    app = this.rootNode || typeAnnotation.app;
+                }
+                const node = newNode((0, utils_1.getNodeByNodeCallee)(app, typeNamespace + '.' + typeName), parentNode, needNewStructure);
+                const properties = node?.properties || [];
+                completionChildren = properties;
+            }
+        }
+        else if (typeKind === 'generic') {
+            const node = newNode((0, utils_1.getNaslNodeByNodeCallee)(typeNamespace, typeName), parentNode, needNewStructure);
+            const properties = (node?.properties && [...node?.properties]) || [];
+            for (let i = 0; i < properties.length; i++) {
+                const item = properties[i];
+                if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                    if (item.name === 'columnItem' && typeArguments[1]) {
+                        item.typeAnnotation = concepts_1.TypeAnnotation.from(typeArguments[1].toJSON(), node, 'typeAnnotation');
+                    }
+                    else if (typeArguments[0]) {
+                        item.typeAnnotation = concepts_1.TypeAnnotation.from(typeArguments[0].toJSON(), node, 'typeAnnotation');
+                    }
+                    properties[i];
+                }
+            }
+            completionChildren = properties;
+        }
+        else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+            const node = newNode((0, utils_1.getNaslNodeByNodeCallee)(typeNamespace, typeName), parentNode, needNewStructure);
+            const properties = (node?.properties && [...node?.properties]) || [];
+            completionChildren = properties;
+        }
+        else if (typeKind === 'anonymousStructure' && typeProperties?.length) {
+            const node = newNode(typeAnnotation, parentNode, needNewStructure);
+            const properties = (node?.properties && [...node?.properties]) || [];
+            completionChildren = properties;
+        }
+        return completionChildren;
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+(0, sentry_1.extendSentryMonitorNaslNode)(concepts_1.BaseNode);
 //# sourceMappingURL=extendBaseNode.js.map