@lcap/nasl 3.8.2-beta.9 → 3.8.3-beta.2

package/src/concepts/Logic__.ts

@@ -49,6 +49,9 @@ import type CallFunction from './CallFunction__';
 import ProcessElementV2 from './ProcessElementV2__';
 import ProcessV2 from './ProcessV2__';
 import type SubLogic from './SubLogic__';
+
+import { reCollectTyInferCtx, varScopeCtx } from '../../../nasl/src/server/semanticData';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1276,7 +1279,7 @@ export class Logic extends Annotatable {
   }
 
   get __isVirtual() {
-    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(this.processV2?.status)
+    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(this.processV2?.status);
     return isDisabled || this.process?.__isVirtual || false;
   }
 
@@ -1551,7 +1554,7 @@ export class Logic extends Annotatable {
     const self = this;
 
     // 获取所有子节点用于树上填充
-    self.getSubLogics()
+    self.getSubLogics();
 
     yield waitOqlQueryComponentChildrenFinish(self);
     let code = '';
@@ -1568,63 +1571,9 @@ export class Logic extends Annotatable {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment | CallFunction> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
+
     const IDENTIFIERMAP = new Set<Variable | Return>();
-    // const needGetSourceMapOqlList: Promise<any>[] = [];
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (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,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
 
     for (const variable of self.variables) {
       const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin('');
@@ -1663,7 +1612,7 @@ export class Logic extends Annotatable {
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                  returnOrigin('');
+              returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -1894,61 +1843,7 @@ export class Logic extends Annotatable {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (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,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
 
     const needChooseParamTypes = completeTypeParams.filter((typeParam) => typeParam.needChoose);
     // 兼容 return 没有类型情况
@@ -2049,7 +1944,7 @@ export class Logic extends Annotatable {
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                  returnOrigin('');
+              returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -2160,7 +2055,7 @@ export class Logic extends Annotatable {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {
@@ -2168,14 +2063,14 @@ export class Logic extends Annotatable {
               itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
-              returnOrigin('');
+                returnOrigin('');
             } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
               code += ' = ';
               itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
             } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
               code += ': ';
               code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-              returnOrigin('');
+                returnOrigin('');
             } else {
               code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
@@ -2294,19 +2189,32 @@ export class Logic extends Annotatable {
     }
 
     code += `(`;
-    if (this.parentNode?.concept === 'BindEvent') {
-      code += `event`;
+    if (state?.typeMap?.[this.nodePath]) {
+      code += state?.typeMap?.[this.nodePath];
+    } else {
+      if (this.parentNode?.concept === 'BindEvent') {
+        // code += `event`;
+      }
+      this.params.forEach((param, index) => {
+        let curCode = '';
+        if (param.name === 'event') curCode += '';
+        else curCode += param.toNaturalTS(shiftState(state, code, { inline: true }));
+        if (curCode && index !== this.params.length - 1) curCode += ', ';
+        code += curCode;
+      });
     }
-    this.params.forEach((param, index) => {
-      code += param.toNaturalTS(shiftState(state, code, { inline: true }));
-      if (index !== this.params.length - 1) code += ', ';
-    });
     code += ')';
 
     // 兼容 return 没有类型情况
-    if (this.returns.length && (this.returns[0].typeAnnotation || this.returns[0].__TypeAnnotation)) {
-      code += ': ';
-      code += this.returns[0].typeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true })) || this.returns[0].__TypeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true }));
+    if (this.returns.length) {
+      if (state?.typeMap?.[this.returns[0]?.nodePath]) {
+        code += ': ';
+        code += state?.typeMap?.[this.returns[0]?.nodePath];
+      } else if (this.returns[0].typeAnnotation || this.returns[0].__TypeAnnotation) {
+        code += ': ';
+        const typeAnnotation = this.returns[0].typeAnnotation || this.returns[0].__TypeAnnotation;
+        code += typeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true }));
+      }
     }
 
     if (state.declaration) {
@@ -2532,8 +2440,8 @@ export class Logic extends Annotatable {
           collectionTSCode === '__IDENTIFIER__'
             ? collectionTSCode
             : callFunction.isLoopMap && index === 0
-            ? `${collectionTSCode}.__getKey(0)`
-            : `${collectionTSCode}.__get(0)`,
+              ? `${collectionTSCode}.__getKey(0)`
+              : `${collectionTSCode}.__get(0)`,
         );
       }
     });
@@ -2675,9 +2583,8 @@ export class Logic extends Annotatable {
     if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
     } else if (this.parentNode.concept === 'BindEvent' && this.getAncestor('Frontend')) {
-      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${
-        this.getAncestor('Frontend')?.name
-      }/bindEvents/${name}.ts`;
+      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${this.getAncestor('Frontend')?.name
+        }/bindEvents/${name}.ts`;
     }
     return `/embedded/${this.getAncestor('App')?.name}${_path}/logics/${name}.ts`;
   }
@@ -2767,9 +2674,9 @@ export class Logic extends Annotatable {
     super.delete();
     this.body.forEach((el) => {
       if (asserts.isCallInterface(el)) {
-        el.deleteCallNode()
+        el.deleteCallNode();
       }
-    })
+    });
     this.traverseChildren(async (el) => {
       if (el?.concept === 'CallQueryComponent') (el as CallQueryComponent).removeStructure();
       // 仅仅针对 自定义连接器下的 Loigc，其他需要界定边界
@@ -2902,6 +2809,9 @@ export class Logic extends Annotatable {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (node?.concept === 'SubLogic') {
         return true;

package/src/concepts/MemberExpression__.ts

@@ -125,7 +125,7 @@ export class MemberExpression extends LogicItem {
       let elementTag;
 
       if (this.object?.namespace?.startsWith('elements.$ce')) {
-        elementName = this.getAncestor('ViewElement')?.name;
+        elementName = this.getAncestor('ViewElement')?.name
       } else {
         elementName = this.object.name;
       }
@@ -173,7 +173,7 @@ export class MemberExpression extends LogicItem {
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
-      return this.transfromAtrrLogic({ type: 'toVue' });
+      return this.transformAtrrLogic({ type: 'toVue' });
     }
 
     const object = String(this.object?.toVue(options)); // undefined 也让正常展示
@@ -302,7 +302,7 @@ export class MemberExpression extends LogicItem {
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
-      return this.transfromAtrrLogic();
+      return this.transformAtrrLogic();
     }
 
     const object: string = this.object?.toJS(state);
@@ -409,10 +409,13 @@ export class MemberExpression extends LogicItem {
     return value;
   }
 
-  transfromAtrrLogic(options?: { type: 'toVue' | 'toJS' }) {
+  transformAtrrLogic(options?: { type: 'toVue' | 'toJS' }) {
     const { type = 'toJS' } = options || {};
 
-    const elementName = this.getAncestor('ViewElement')?.name;
+    const elementName = this.getAncestor('ViewElement')?.name
+    // varScopeCtx.isFirstScreen
+    //     ? varScopeCtx.memExprToViewElem.get(this)?.name
+    //     : this.getAncestor('ViewElement')?.name;
     let element;
     let elementTag;
 
@@ -490,6 +493,17 @@ export class MemberExpression extends LogicItem {
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
     let code = '';
+
+    // 变量提升且是调用逻辑取属性，此时需要翻译为立即执行函数规避 TS 的 BUG
+    if (asserts.isCallLogic(self.object) && state.isVariableHost) {
+      code += '(() => {\nconst __$1 = ';
+      code += `${yield* self.object.toEmbeddedTS(shiftState(state, code, { inline: true }))};\n`
+      code += `return __$1.`;
+      code += self.property ? yield* self.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
+      code += ';})()';
+      return code;
+    }
+
     const leftCode = self.object
       ? `${yield* self.object.toEmbeddedTS(shiftState(state, code, { inline: true }))}.`
       : '';
@@ -516,7 +530,7 @@ export class MemberExpression extends LogicItem {
     ) {
       let newCode = '';
       if (self.object?.namespace?.startsWith('elements.$ce')) {
-        const elementName = self.getAncestor('ViewElement')?.name;
+        const elementName = self.getAncestor('ViewElement')?.name
         newCode += `__elements['${elementName}']`;
         if (asserts.isIdentifier(self.property) && self.property?.name) {
           newCode += `['${self.property?.name}']`;
@@ -537,7 +551,7 @@ export class MemberExpression extends LogicItem {
       self.object?.property?.name === '$ce'
     ) {
       let newCode = '';
-      const elementName = self.getAncestor('ViewElement')?.name;
+      const elementName = self.getAncestor('ViewElement')?.name
       newCode += `__elements['${elementName}']`;
       newCode += `.${self.property?.name}`;
       return newCode;

package/src/concepts/OqlQueryComponent__.ts

@@ -16,7 +16,8 @@ import type Identifier from './Identifier__';
 import type MemberExpression from './MemberExpression__';
 import type { Entity } from './Entity__';
 import type { EntityProperty } from './EntityProperty__';
-import logicService from '../service/logic';
+import { naslOQLCacheStore } from '../utils/language-cache/nasl';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -303,8 +304,8 @@ export class OqlQueryComponent extends LogicItem {
         };
       }
 
-      return http
-        .post('/api/v1/querydebug/generate/typescript', {
+      const query = async () => {
+        const params = {
           appId: 'myAppId',
           oqlIdentifier: 'myoqlIdentifier',
           dataSourceName: this.dataSource,
@@ -313,8 +314,31 @@ export class OqlQueryComponent extends LogicItem {
           dataSourceNasl,
           typeScriptStartLine: 1,
           typeScriptStartLineColumn: 1,
-        })
-        .then(({ data }: any) => {
+        };
+        const key = JSON.stringify(params);
+        let res = null;
+        let canUseCache = false;
+        try {
+          res = await naslOQLCacheStore.getItem(key);
+          canUseCache = true;
+        } catch (error) {}
+        if (res !== null) {
+          return res;
+        }
+        return http
+          .post('/api/v1/querydebug/generate/typescript', params)
+          .then(async ({ data }) => {
+            if (canUseCache) {
+              try {
+                await naslOQLCacheStore.setItem(key, data);
+              } catch (error) {}
+            }
+            return data;
+          });
+      };
+
+      return query()
+        .then((data: any) => {
           this.codeSourceMap = data.result ?? { typescript: '', lexicalErrorCode: 1001 };
         })
         .catch((err) => {

package/src/concepts/OverriddenLogic__.ts

@@ -59,6 +59,7 @@ import Param from './Param__';
 import Return from './Return__';
 import Variable from './Variable__';
 import LogicItem from './LogicItem__';
+import { reCollectTyInferCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 覆写逻辑
@@ -1584,61 +1585,8 @@ export class OverriddenLogic extends BaseNode {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (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,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
+
     // 兼容 return 没有类型情况
     if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
@@ -1778,7 +1726,7 @@ export class OverriddenLogic extends BaseNode {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {

package/src/concepts/Param__.ts

@@ -329,12 +329,13 @@ export class Param extends BaseNode {
     if (asserts.isFunction(this.defaultExpression) || asserts.isAnonymousFunction(this.defaultExpression)) {
       code += this.defaultValue?.expression || this.defaultExpression ? '?: ' : ': ';
       code += runSync(this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code)));
-    } else if (!dontType && this.typeAnnotation) {
+    } else if (!dontType && (this.typeAnnotation || this.__TypeAnnotation)) {
+      const typeAnnotation = this?.typeAnnotation || this?.__TypeAnnotation;
       code += ': ';
-      code += this.typeAnnotation.toNaturalTS(shiftState(state, code));
-      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
+      code += typeAnnotation?.toNaturalTS(shiftState(state, code));
+      if (typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
         if (this.isEnum()) {
-          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+          code += `= ${typeAnnotation.typeKey}['${this.defaultValue}']`;
         }
       }
     }

package/src/concepts/ProcessElementV2__.ts

@@ -45,6 +45,7 @@ import FlowConditionV2 from './FlowConditionV2__';
 import Logic from './Logic__';
 import BindEvent from './BindEvent__';
 import ApprovalPolicyV2 from './ApprovalPolicyV2__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 流程元素
@@ -1536,6 +1537,9 @@ export class ProcessElementV2 extends BaseNode {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/ProcessElement__.ts

@@ -43,6 +43,7 @@ import Return from './Return__';
 import Constant from './Constant__';
 import BindAttribute from './BindAttribute__';
 import MultiApprovalPolicy from './MultiApprovalPolicy__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 流程元素
@@ -1733,6 +1734,9 @@ export class ProcessElement extends BaseNode {
     // 只有 AutoTask 才需要在他的节点下找子逻辑
     // 其他直接在 BindEvent 下找
     if (this.type !== 'AutoTask') return [] as SubLogic[];
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/ProcessV2__.ts

@@ -28,6 +28,8 @@ import ProcessElementV2 from './ProcessElementV2__';
 import HistoryProcessV2 from './HistoryProcessV2__';
 import ProcessBindV2 from './ProcessBindV2__';
 import BindEvent from './BindEvent__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
+
 /**
  * 流程
  */
@@ -1046,6 +1048,9 @@ export class ProcessV2 extends BaseNode {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/Process__.ts

@@ -36,6 +36,7 @@ import Param from './Param__';
 import Return from './Return__';
 import Constant from './Constant__';
 import ProcessElement from './ProcessElement__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 流程
@@ -1497,6 +1498,9 @@ export class Process extends BaseNode {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen)  {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/QueryOrderByExpression__.ts

@@ -114,7 +114,6 @@ export class QueryOrderByExpression extends LogicItem {
   public static getDefaultOptions() {
     return {
       concept: 'QueryOrderByExpression',
-      label: '查询组件OrderBy元素',
       orderElement: {
         concept: 'QueryFieldExpression',
       },

package/src/concepts/Structure__.ts

@@ -573,16 +573,14 @@ export class Structure extends BaseNode {
         .join(', ')}>`;
     }
 
-    code += ` {`;
-    if (state.descriptionComment && this.description)
-      code += `/* ${this.description} */`;
-    code += '\n';
+    code += ` {\n`;
+    // if (state.descriptionComment && this.description)
+    //   code += `/* ${this.description} */`;
+    // code += '\n';
 
     // code += `${indent(state.tabSize + 1)}__name: '${this.getNamespace()}.${this.name}';\n`;
     this.properties.forEach((property) => {
-      code += indent(state.tabSize + 1);
-      code += property.toNaturalTS(shiftState(state, code, { tabSize: 0 }));
-      code += ';\n';
+      code += `${property.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }))};\n`;
     });
     code += `${indent(state.tabSize)}}\n`;
     return code;