@lcap/nasl 3.8.0-beta.3 → 3.8.0-beta.5

package/src/concepts/FrontendLibrary__.ts

@@ -13,7 +13,7 @@ import { createUUID } from '../utils/create';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import BaseNode from '../common/BaseNode';
-import LogicDeclaration from './LogicDeclaration__';
+import Logic from './Logic__';
 import ViewComponentDeclaration from './ViewComponentDeclaration__';
 
 /**
@@ -59,11 +59,11 @@ export class FrontendLibrary extends BaseNode {
    * 依赖库逻辑声明列表
    */
   @property({
-    objectRef: 'LogicDeclaration',
+    objectRef: 'Logic',
     isArray: true,
     defaultValue: [],
   })
-  logics: Array<LogicDeclaration> = [];
+  logics: Array<Logic> = [];
 
   /**
    * 依赖库组件声明列表
@@ -88,98 +88,96 @@ export class FrontendLibrary extends BaseNode {
     return super.from(source, parentNode, parentKey) as FrontendLibrary;
   }
 
-  getLogicDeclarationExistingNames(excludedList: Array<LogicDeclaration> = []) {
+  getLogicExistingNames(excludedList: Array<Logic> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.logics as LogicDeclaration[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item.name);
+    return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getLogicDeclarationUniqueName(name = 'logicDeclaration1') {
-    return utils.unique(name, this.getLogicDeclarationExistingNames(), undefined, true);
+  getLogicUniqueName(name = 'logic1') {
+    return utils.unique(name, this.getLogicExistingNames(), undefined, true);
   }
 
   /**
-   * 插入逻辑声明
+   * 插入逻辑
    * @internal
-   * @param name 逻辑声明名称，如果不填会自动生成一个唯一名称
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertLogicDeclarationAt(name: string, index: number): LogicDeclaration;
+  _insertLogicAt(name: string, index: number): Logic;
 
   /**
-   * 插入逻辑声明
+   * 插入逻辑
    * @internal
-   * @param logicDeclarationOptions 逻辑声明参数
+   * @param logicOptions 逻辑参数
    */
-  _insertLogicDeclarationAt(logicDeclarationOptions: Partial<LogicDeclaration>, index: number): LogicDeclaration;
+  _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
-   * 插入逻辑声明
+   * 插入逻辑
    * @internal
-   * @param logicDeclaration 已有的逻辑声明实例
+   * @param logic 已有的逻辑实例
    */
-  _insertLogicDeclarationAt(logicDeclaration: LogicDeclaration, index: number): LogicDeclaration;
+  _insertLogicAt(logic: Logic, index: number): Logic;
 
-  _insertLogicDeclarationAt(options: string | Partial<LogicDeclaration> | LogicDeclaration, index: number) {
-    const logicDeclarationOptions: any = {};
+  _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+    const logicOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'logics' };
-    const LogicDeclaration = getConceptConstructor('LogicDeclaration');
-    let logicDeclaration: LogicDeclaration;
+    const Logic = getConceptConstructor('Logic');
+    let logic: Logic;
     if (!options) {
-      logicDeclaration = LogicDeclaration.from(
+      logic = Logic.from(
         {
-          ...logicDeclarationOptions,
-          name: this.getLogicDeclarationUniqueName(),
+          ...logicOptions,
+          name: this.getLogicUniqueName(),
         },
         this,
         'logics',
       );
     } else if (typeof options === 'string') {
-      logicDeclaration = LogicDeclaration.from(
+      logic = Logic.from(
         {
-          ...logicDeclarationOptions,
+          ...logicOptions,
           name: options,
         },
         this,
         'logics',
       );
-    } else if (asserts.isLogicDeclaration(options)) {
+    } else if (asserts.isLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      logicDeclaration = options;
-      Object.assign(logicDeclaration, relationOptions);
+      logic = options;
+      Object.assign(logic, relationOptions);
     } else {
-      logicDeclaration = LogicDeclaration.from(
+      logic = Logic.from(
         {
-          ...logicDeclarationOptions,
+          ...logicOptions,
           ...options,
         },
         this,
         'logics',
       );
     }
-    this.logics.splice(index, 0, logicDeclaration);
-    return logicDeclaration;
+    this.logics.splice(index, 0, logic);
+    return logic;
   }
 
   /**
-   * 插入逻辑声明
-   * @param name 逻辑声明名称，如果不填会自动生成一个唯一名称
+   * 插入逻辑
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertLogicDeclarationAt(name: string, index: number): LogicDeclaration;
+  insertLogicAt(name: string, index: number): Logic;
 
   /**
-   * 插入逻辑声明
-   * @param logicDeclarationOptions 逻辑声明参数
+   * 插入逻辑
+   * @param logicOptions 逻辑参数
    */
-  insertLogicDeclarationAt(logicDeclarationOptions: Partial<LogicDeclaration>, index: number): LogicDeclaration;
+  insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
-   * 插入逻辑声明
-   * @param logicDeclaration 已有的逻辑声明实例
+   * 插入逻辑
+   * @param logic 已有的逻辑实例
    */
-  insertLogicDeclarationAt(logicDeclaration: LogicDeclaration, index: number): LogicDeclaration;
+  insertLogicAt(logic: Logic, index: number): Logic;
 
-  insertLogicDeclarationAt(options: string | Partial<LogicDeclaration> | LogicDeclaration, index: number) {
-    const node = this._insertLogicDeclarationAt(options as any, index);
+  insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+    const node = this._insertLogicAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -189,52 +187,52 @@ export class FrontendLibrary extends BaseNode {
   }
 
   /**
-   * 添加逻辑声明
+   * 添加逻辑
    * @internal
-   * @param name 逻辑声明名称，如果不填会自动生成一个唯一名称
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addLogicDeclaration(name?: string): LogicDeclaration;
+  _addLogic(name?: string): Logic;
 
   /**
-   * 添加逻辑声明
+   * 添加逻辑
    * @internal
-   * @param logicDeclarationOptions 逻辑声明参数
+   * @param logicOptions 逻辑参数
    */
-  _addLogicDeclaration(logicDeclarationOptions: Partial<LogicDeclaration>): LogicDeclaration;
+  _addLogic(logicOptions: Partial<Logic>): Logic;
 
   /**
-   * 添加逻辑声明
+   * 添加逻辑
    * @internal
-   * @param logicDeclaration 已有的逻辑声明实例
+   * @param logic 已有的逻辑实例
    */
-  _addLogicDeclaration(logicDeclaration: LogicDeclaration): LogicDeclaration;
+  _addLogic(logic: Logic): Logic;
 
-  _addLogicDeclaration(options?: string | Partial<LogicDeclaration> | LogicDeclaration) {
+  _addLogic(options?: string | Partial<Logic> | Logic) {
     const index = this.logics.length;
-    return this._insertLogicDeclarationAt(options as any, index);
+    return this._insertLogicAt(options as any, index);
   }
 
   /**
-   * 添加逻辑声明
+   * 添加逻辑
    * @internal
-   * @param name 逻辑声明名称，如果不填会自动生成一个唯一名称
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addLogicDeclaration(name?: string): LogicDeclaration;
+  addLogic(name?: string): Logic;
 
   /**
-   * 添加逻辑声明
-   * @param logicDeclarationOptions 逻辑声明参数
+   * 添加逻辑
+   * @param logicOptions 逻辑参数
    */
-  addLogicDeclaration(logicDeclarationOptions: Partial<LogicDeclaration>): LogicDeclaration;
+  addLogic(logicOptions: Partial<Logic>): Logic;
 
   /**
-   * 添加逻辑声明
-   * @param logicDeclaration 已有的逻辑声明实例
+   * 添加逻辑
+   * @param logic 已有的逻辑实例
    */
-  addLogicDeclaration(logicDeclaration: LogicDeclaration): LogicDeclaration;
+  addLogic(logic: Logic): Logic;
 
-  addLogicDeclaration(options?: string | Partial<LogicDeclaration> | LogicDeclaration) {
-    const node = this._addLogicDeclaration(options as any);
+  addLogic(options?: string | Partial<Logic> | Logic) {
+    const node = this._addLogic(options as any);
     const index = this.logics.indexOf(node);
     node.create({
       index,
@@ -423,28 +421,28 @@ export class FrontendLibrary extends BaseNode {
   }
 
   /**
-   * 删除逻辑声明
-   * @param name 逻辑声明名称
+   * 删除逻辑
+   * @param name 逻辑名称
    */
-  removeLogicDeclaration(name: string): void;
+  removeLogic(name: string): void;
 
   /**
-   * 删除逻辑声明
-   * @param logicDeclaration 已有的逻辑声明实例
+   * 删除逻辑
+   * @param logic 已有的逻辑实例
    */
-  removeLogicDeclaration(logicDeclaration: LogicDeclaration): void;
+  removeLogic(logic: Logic): void;
 
-  removeLogicDeclaration(options: string | LogicDeclaration) {
-    let logicDeclaration: LogicDeclaration;
+  removeLogic(options: string | Logic) {
+    let logic: Logic;
     if (typeof options === 'string') {
-      logicDeclaration = (this.logics as LogicDeclaration[]).find((item) => item.name === options);
-      if (!logicDeclaration) {
-        throw new Error('找不到逻辑声明 ' + options);
+      logic = (this.logics as Logic[]).find((item) => item.name === options);
+      if (!logic) {
+        throw new Error('找不到逻辑 ' + options);
       }
     } else {
-      logicDeclaration = options;
+      logic = options;
     }
-    return logicDeclaration.delete();
+    return logic.delete();
   }
 
   /**

package/src/concepts/I18nInfo__.ts

@@ -92,6 +92,11 @@ export class I18nInfo extends BaseNode {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    return '';
+  }
+
   get messagesLanguageList() {
     return Object.keys(this.messageMap || {});
   }

package/src/concepts/IfStatement__.ts

@@ -468,7 +468,7 @@ export class IfStatement extends LogicItem {
     });
     if (state.focusedNodePath === `${this.nodePath}.alternate[${this.alternate.length}]`)
       code += `${indent((state?.tabSize || 0) + 1)}/* 当前位置 */\n`;
-    code += `${indent(state?.tabSize || 0)}}\n`;
+    code += `${indent(state?.tabSize || 0)}}`;
     return code;
   }
 
@@ -506,7 +506,7 @@ export class IfStatement extends LogicItem {
     });
     if (state.focusedNodePath === `${this.nodePath}.alternate[${this.alternate.length}]`)
       code += `${indent((state?.tabSize || 0) + 1)}/* 当前位置 */\n`;
-    code += `${indent(state?.tabSize || 0)}}\n`;
+    code += `${indent(state?.tabSize || 0)}}`;
     return code;
   }
 

package/src/concepts/Interface__.ts

@@ -9,6 +9,7 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
+  createDescriptionComment,
 } from '../translator';
 import type Namespace from './Namespace__';
 import type TypeAnnotation from './TypeAnnotation__';
@@ -978,7 +979,11 @@ export class Interface extends ImportedInterface {
   @withSourceMap()
   toNaturalTS(state = createCompilerState(), interfaceName: string): string {
     const { name, params, returns } = this || {};
-    let code = `declare function ${interfaceName || name}(`;
+
+    let code = '';
+    if (state.descriptionComment)
+      code += createDescriptionComment(state, this, ['description']);
+    code = `declare function ${interfaceName || name}(`;
     if (params?.length) {
       code += '{';
       params?.forEach((param, index) => {

package/src/concepts/Logic__.ts

@@ -17,6 +17,7 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
+  createDescriptionComment,
 } from '../translator';
 import type App from './App__';
 import type Namespace from './Namespace__';
@@ -1274,7 +1275,8 @@ export class Logic extends Annotatable {
   }
 
   get __isVirtual() {
-    return this.processV2?.__isVirtual || this.process?.__isVirtual || false;
+    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(this.processV2?.status)
+    return isDisabled || this.process?.__isVirtual || false;
   }
 
   // 用于calllogic树中定位是那个logic，回显
@@ -1577,6 +1579,9 @@ export class Logic extends Annotatable {
           // 内置函数对集合类型的推导
           (asserts.isCallFunction(el) && el.derivablecollection?.name))
       ) {
+        if (el?.getAncestor('SubLogic')) {
+          return;
+        }
         if (asserts.isAssignment(el)) {
           const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
@@ -1772,11 +1777,26 @@ export class Logic extends Annotatable {
   toEmbeddedTSNoExport(state?: TranslatorState): string {
     return runSync(this.toEmbeddedTS(state, 'noExport'));
   }
-  get tsName() {
+  get tsName(): string {
+    const { parentNode: parent, connector, integration, view, name } = this;
+
+    if (!view || parent.concept !== 'BindEvent') {
+      return this.name;
+    }
+
     // 来自集成中心，且是连接内部的逻辑，则认为是编辑态的，需要加上后缀
-    if (this.connector && this.integration) {
+    if (connector && integration) {
       return `${this.name}${CUSTOM_CONNECTOR_EDITABLE_SUFFIX}`;
     }
+
+    const { parentNode: grandPar } = parent;
+
+    if (grandPar.concept === 'View') {
+      return `$$_view_${parent.parentNode.name}_bind_event_${name}`;
+    }
+    else if (grandPar.concept === 'ViewElement') {
+      return `$$_view_element_${parent.parentNode.name}_bind_event_${name}`;
+    }
     // 由于Logic name 已经是符合函数预期的，因此不再需要做格式化
     return this.name;
   }
@@ -1883,6 +1903,9 @@ export class Logic extends Annotatable {
           // 内置函数对集合类型的推导
           (asserts.isCallFunction(el) && el.derivablecollection?.name))
       ) {
+        if (el?.getAncestor('SubLogic')) {
+          return;
+        }
         if (asserts.isAssignment(el)) {
           const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
@@ -2214,6 +2237,8 @@ export class Logic extends Annotatable {
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
     let code = '';
+    if (state.descriptionComment)
+      code += createDescriptionComment(state, this, ['description']);
 
     let logicName = this.name;
     if (state.autoPrefixName) {
@@ -2380,6 +2405,10 @@ export class Logic extends Annotatable {
       const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
       return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
     }
+    // 调用依赖库逻辑可能会有子逻辑，子逻辑拼接可能有ts忽略先去掉
+    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace?.startsWith('extensions.')) {
+      code = code.replaceAll('// @ts-ignore', '');
+    }
 
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = assignment.getAncestor('ForEachStatement') as ForEachStatement;
@@ -2689,6 +2718,11 @@ export class Logic extends Annotatable {
       actionMsg,
     });
     super.delete();
+    this.body.forEach((el) => {
+      if (asserts.isCallInterface(el)) {
+        el.deleteCallNode()
+      }
+    })
     this.traverseChildren(async (el) => {
       if (el?.concept === 'CallQueryComponent') (el as CallQueryComponent).removeStructure();
       // 仅仅针对 自定义连接器下的 Loigc，其他需要界定边界
@@ -2855,18 +2889,13 @@ export class Logic extends Annotatable {
     return Array.from(this.existingSubLogic);
   }
 
-  getSubLogicUniqueName(name = 'subLogic1') {
+  getSubLogicUniqueName(name = 'subLogic1', excludedNames: Array<string> = []) {
     const existingNames = this.getSubLogicExistingNames();
-    const uniqueName = utils.unique(name, existingNames, undefined, false);
+    const uniqueName = utils.unique(name, existingNames.concat(excludedNames), undefined, false);
     this.existingSubLogic.add(uniqueName);
     return uniqueName;
   }
 
-  genActionListener($event: EventPayload): void {
-    super.genActionListener($event);
-    invokeCommand('logic.update', this);
-  }
-
   /**
    * 完成的泛型参数
    * 先指支持依赖库的泛型参数

package/src/concepts/MatchCase__.ts

@@ -150,15 +150,6 @@ export class MatchCase extends LogicItem {
     return logicItem;
   }
 
-  getLogicItemExistingNames(excludedList: Array<LogicItem> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.patterns as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-
-  getLogicItemUniqueName(name = 'logicItem1') {
-    return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
-  }
-
   /**
    * 插入逻辑项
    * @param logicItemOptions 逻辑项参数
@@ -591,6 +582,14 @@ export class MatchCase extends LogicItem {
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
 
+  getLogicItemExistingNames(excludedList: Array<LogicItem> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.patterns as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getLogicItemUniqueName(name = 'logicItem1') {
+    return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
+  }
+
   // 是否处于禁用状态
   get isDisabled() {
     const matchExpression = this.parentNode as Match;

package/src/concepts/NewComposite__.ts

@@ -1024,7 +1024,8 @@ export class NewComposite extends LogicItem {
     if (!this.typeAnnotation) return null;
     // 祖先逻辑
     const ancestorLogic = this.getAncestor('Logic');
-    if (ancestorLogic) {
+    const bindAttribute = this.getAncestor('BindAttribute');
+    if (ancestorLogic || bindAttribute?.name === 'dataSource') {
       code += 'await (async () => { \n';
     } else {
       code += '(() => { \n';

package/src/concepts/NewList__.ts

@@ -320,7 +320,8 @@ export class NewList extends LogicItem {
     let code = '';
     // 祖先逻辑
     const ancestorLogic = this.getAncestor('Logic');
-    if (ancestorLogic) {
+    const bindAttribute = this.getAncestor('BindAttribute');
+    if (ancestorLogic || bindAttribute?.name === 'dataSource') {
       code += 'await (async () => { \n';
     } else {
       code += '(() => { \n';

package/src/concepts/NewMap__.ts

@@ -543,7 +543,8 @@ export class NewMap extends LogicItem {
     let code = '';
     // 祖先逻辑
     const ancestorLogic = this.getAncestor('Logic');
-    if (ancestorLogic) {
+    const bindAttribute = this.getAncestor('BindAttribute');
+    if (ancestorLogic || bindAttribute?.name === 'dataSource') {
       code += 'await (async () => { \n';
     } else {
       code += '(() => { \n';

package/src/concepts/OqlQueryComponent__.ts

@@ -124,17 +124,9 @@ export class OqlQueryComponent extends LogicItem {
 
   getTextVariables() {
     this._TsVariables = [];
-    const str = this.code;
-    const variables: Set<string> = new Set();
     const Identifier = getConceptConstructor('Identifier');
     const MemberExpression = getConceptConstructor('MemberExpression');
-    let temp: any;
-    const re = /\{(.+?)\}/g;
-    while ((temp = re.exec(str))) {
-      let variable = temp[1];
-      variable = variable.replaceAll(' ', '');
-      variables.add(variable);
-    }
+    const variables: Array<string> = this.codeSourceMap?.variableNames || [];
     for (const variable of variables) {
       // 遍历Set
       let newVariable: Identifier | MemberExpression;
@@ -252,10 +244,10 @@ export class OqlQueryComponent extends LogicItem {
     if (typescript) {
       code += `${indent1}const __oqlQueryResult = ${typescript};`;
     }
-    // 临时方案拼接字符串
-    self.getTextVariables();
     // 翻译字段
     code += '\n';
+    // 从接口获取可以调试变量的字段，用作下面翻译，作为后面调试的变量。拼接
+    self.getTextVariables();
     yield* wrapForEach(self._TsVariables, function* warpForEachGenerator(variable) {
       code += yield* variable.toEmbeddedTS(shiftState(state, code));
       code += ';\n';

package/src/concepts/OverriddenLogic__.ts

@@ -1594,6 +1594,9 @@ export class OverriddenLogic extends BaseNode {
           // 内置函数对集合类型的推导
           (asserts.isCallFunction(el) && el.derivablecollection?.name))
       ) {
+        if (el?.getAncestor('SubLogic')) {
+          return;
+        }
         if (asserts.isAssignment(el)) {
           const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
@@ -1976,6 +1979,10 @@ export class OverriddenLogic extends BaseNode {
       const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
       return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
     }
+    // 调用依赖库逻辑可能会有子逻辑，子逻辑拼接可能有ts忽略先去掉
+    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace?.startsWith('extensions.')) {
+      code = code.replaceAll('// @ts-ignore', '');
+    }
 
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = assignment.getAncestor('ForEachStatement') as ForEachStatement;

package/src/concepts/Param__.ts

@@ -194,6 +194,7 @@ export class Param extends BaseNode {
   }
 
   @excludedInJSON()
+  @property()
   required: boolean;
 
   @excludedInJSON()

package/src/concepts/ProcessElementV2__.ts

@@ -23,6 +23,7 @@ import type Namespace from './Namespace__';
 import type View from './View__';
 import type HistoryProcessV2 from './HistoryProcessV2__';
 import type ProcessV2 from './ProcessV2__';
+import type SubLogic from './SubLogic__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1251,7 +1252,8 @@ export class ProcessElementV2 extends BaseNode {
   }
 
   get __isVirtual() {
-    return this.processV2.__isVirtual;
+    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(this.processV2.status)
+    return isDisabled;
   }
 
   get AssigneeV2() {
@@ -1351,6 +1353,9 @@ export class ProcessElementV2 extends BaseNode {
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
+    // 获取所有子节点用于树上填充
+    self.getSubLogics();
+
     const tab1 = indent((state?.tabSize || 0) + 1);
     const tab2 = indent((state?.tabSize || 0) + 2);
     const tab3 = indent((state?.tabSize || 0) + 3);
@@ -1528,22 +1533,15 @@ export class ProcessElementV2 extends BaseNode {
     return code;
   }
 
-  get subLogic() {
-    // 只有自动任务需要， 其他的UI展示上均在其下面的 Logic 中
-    if (this.type === 'ServiceTask') {
-      const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
-        if (asserts.isSubLogic(node)) {
-          return true;
-        }
-      });
-      return subLogics;
-    }
-    return [];
-  }
+  subLogics: Array<SubLogic> = [];
 
-  genActionListener($event: EventPayload): void {
-    super.genActionListener($event);
-    invokeCommand('logic.update', this);
+  getSubLogics() {
+    const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
+      if (asserts.isSubLogic(node)) {
+        return true;
+      }
+    });
+    this.subLogics = subLogics as Array<SubLogic>;
   }
 
   //================================================================================