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

package/src/concepts/ViewElement__.ts

@@ -81,6 +81,7 @@ function genArgumentMemberExpression(arr: string[]) {
 export interface ElementToVueOptions {
   filterAttr?:  Array<string>;
   isExport?: boolean;
+  isRelease?: boolean;
   isRoot?: boolean;
   asCompontent?: boolean;
   indentStyle?: 'space' | 'tab';
@@ -1633,31 +1634,44 @@ export class ViewElement extends Annotatable {
     let levelIndex = parentLevel || 0;
     code += `${self.name}: () => {\n`;
 
-    const getType = (name: string) => {
-      let t;
+    const getMultipleDefaultValue = (name: string) => {
+      let v = 'new nasl.core.BooleanFalse()';
       const attr = self.bindAttrs?.find((attr) => attr.name === name);
       if (['static', 'string'].includes(attr?.type)) {
-        t = attr.value ? 'true' : 'false';
-      } else if (['dynamic'].includes(attr?.type)) {
-        t = 'nasl.core.Boolean';
-      } else {
-        t = false;
+        v = attr.value ? 'new nasl.core.BooleanTrue()' : 'new nasl.core.BooleanFalse()';
       }
 
-      return t;
+      return v;
     };
-    const hasDataSource =
-      config?.allNodesAPI?.[self.tag]?.props?.findIndex((prop) => ['dataSource', 'data-source'].includes(prop.name)) >
-      -1;
+    const getConverterDefaultValue = (name: string) => {
+      let v = 'new nasl.core.StringLiteral<\`\`>()';
+      const attr = self.bindAttrs?.find((attr) => attr.name === name);
+      if (['static', 'string'].includes(attr?.type)) {
+        if ([true, 'true'].includes(attr.value)) {
+          v = 'new nasl.core.BooleanTrue()';
+        } else if ([false, 'false'].includes(attr.value)) {
+          v = 'new nasl.core.BooleanFalse()';
+        } else {
+          v = `new nasl.core.StringLiteral<\`${attr.value}\`>()`;
+        }
+      }
+
+      return v;
+    }
+
+    const hasDataSource = config?.allNodesAPI?.[self.tag]?.props?.findIndex((prop) => ['dataSource', 'data-source'].includes(prop.name)) > -1;
+    let dataSourceSetted = false;
+    let staticItem = '';
     // 有数据源属性的组件 才需要生成 item
     if (hasDataSource && T) {
       const key = T1 ? '__columnItem' : '__item';
       const dataSourceAttr = self.bindAttrs?.find((attr) => attr.name === 'dataSource');
       if (dataSourceAttr?.expression) {
+        dataSourceSetted = true;
         if (
           asserts.isMemberExpression(dataSourceAttr.expression) ||
           asserts.isIdentifier(dataSourceAttr.expression) ||
-          asserts.isCallLogic(dataSourceAttr.expression)
+          (asserts.isCallLogic(dataSourceAttr.expression)  && !dataSourceAttr.expression?.calleeNamespace?.startsWith('extensions'))
         ) {
           const value = yield* dataSourceAttr.expression.toEmbeddedTS(
             shiftState(
@@ -1711,40 +1725,80 @@ export class ViewElement extends Annotatable {
           code += `let ${key}: nasl.ui.GetItemTypeFromDataSource<ReturnType<typeof _load>>;\n`;
         }
       } else {
-        code += `let ${key}: any;\n`;
+        // 根据静态子节点生成类型
+        const attrs: Record<string, string> = {
+          'u-checkbox': 'label',
+          'u-radio': 'label',
+          'van-radio': 'name',
+          'van-checkbox': 'label',
+        }
+        const child = self.children?.filter((item) => item.tag !== 'template')[0];
+        if (child as ViewElement) {
+          const valueAttr = child.bindAttrs?.find((attr) => attr.name === (attrs[child.tag] || 'value'));
+          if (valueAttr) {
+            // 开启了绑定
+            if (valueAttr.expression) {
+              const attrCode = yield* valueAttr.expression.toEmbeddedTS(shiftState(state, '', { tabSize: 0 }));
+              staticItem = `${attrCode}`;
+            } else {
+              try {
+                if (valueAttr.type === 'static') {
+                  const value = json5.parse(valueAttr.value);
+                  const map: Record<string, string> = {
+                    'string': 'new nasl.core.String("")',
+                    'number': 'new nasl.core.Long(1)',
+                    'boolean': 'new nasl.core.Boolean(false)',
+                  }
+
+                  staticItem = map[typeof value] || 'new nasl.core.String("")';
+                } else {
+                  staticItem = 'new nasl.core.String("")';
+                }
+              } catch (error) {
+                // @ts-ignore
+              }
+            }
+          } else {
+            staticItem = 'new nasl.core.String("")';
+          }
+        }
+        code += `let __staticItem = ${staticItem};\n`;
+        code += `let ${key}: typeof __staticItem;\n`;
       }
     }
     // 值
     let valueType: string;
     if (hasDataSource && V && !T1) {
       const valueFieldAttr = self.bindAttrs?.find((attr) => attr.name === 'valueField');
-      if (['static', 'string'].includes(valueFieldAttr?.type)) {
+      if (dataSourceSetted && ['static', 'string'].includes(valueFieldAttr?.type)) {
         valueType = `typeof __item.${valueFieldAttr.value}`;
       } else {
-        valueType = 'any';
+        valueType = `typeof __staticItem`;
       }
     }
     // 分页
-    let pageableType: string | boolean;
+    let pageableDefaultValue: string;
     if (hasDataSource && P && !T1) {
-      pageableType = getType('pageable');
-      code += `let __pageable: ${pageableType};\n`;
+      pageableDefaultValue = getMultipleDefaultValue('pageable');
+      code += `let __pageable = ${pageableDefaultValue};\n`;
     }
     // 多选
-    let multipleType: string | boolean;
+    let multipleDefaultValue: string;
     if (hasDataSource && M && !T1) {
-      multipleType = getType('multiple');
-      code += `let __multiple: ${multipleType};\n`;
+      multipleDefaultValue = getMultipleDefaultValue('multiple');
+      code += `let __multiple = ${multipleDefaultValue};\n`;
     }
     if (hasDataSource && V && !T1) {
       code += `// @ts-ignore
-      let __value: ${valueType}${[true, 'true'].includes(multipleType) ? '[]' : ''};\n`;
+      let __value: typeof __multiple extends nasl.core.BooleanTrue ? ${valueType}[] : ${valueType};\n`;
       code += `// @ts-ignore
       let __V: ${valueType};\n`;
     }
+
+    let converterDefaultValue: string;
     if (C) {
-      // code += `let converter: ${getType('converter')};\n`;
-      code += `let __converter: any;\n`;
+      converterDefaultValue = getConverterDefaultValue('converter');
+      code += `let __converter = ${converterDefaultValue};\n`;
     }
 
     if (self.tag === 'template' && self.haveScope() && asserts.isViewElement(self.parentNode)) {
@@ -2055,12 +2109,10 @@ export class ViewElement extends Annotatable {
         return;
       }
 
-      let attrCode = yield* attr.toEmbeddedTS(shiftState(state, code, { tabSize: 1 }));
+      let attrCode = yield* attr.toEmbeddedTS(shiftState(state, code, { tabSize: 1 }), { carryName: true });
 
       if (attrCode.trim()) {
-        const humpName = self.toHump(attr.name);
-        code += `${humpName}: `;
-        attrCode = yield* attr.toEmbeddedTS(shiftState(state, code, { tabSize: 1 }));
+        attrCode = yield* attr.toEmbeddedTS(shiftState(state, code, { tabSize: 1 }), { carryName: true });
         code += attrCode;
         code += `,\n`;
       }
@@ -2149,7 +2201,8 @@ export class ViewElement extends Annotatable {
         const param = hasScope ? `current${levelIndex === 0 ? '' : levelIndex}` : '';
         const levelIndexDelta = Number(hasScope);
         code += `slotDefault: (${param}) => [\n`;
-        yield* wrapForEach(children, function* warpForEachGenerator(element) {
+        const defaultArr = self.shouldHandleChildren(self) ? children : [];
+        yield* wrapForEach(defaultArr, function* warpForEachGenerator(element) {
           code += yield* element.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: (state?.tabSize || 0) + 2,
@@ -2173,6 +2226,29 @@ export class ViewElement extends Annotatable {
     return code;
   }
 
+  shouldHandleChildren(element: ViewElement) {
+    // 数据源与静态子节点不共存的组件
+    const tags = [
+      'u-tabs',
+      'u-selectable-steps',
+      'van-swipe',
+      'van-steps',
+    ]; // 数据源与静态子节点不共存的组件
+
+    // 判断当前是否配置了数据源
+    const isDataSourceConfigured = () => element.bindAttrs.some((attr) => {
+      if (['data-source', 'dataSource'].includes(attr.name)) {
+        if (attr.type === 'dynamic' && attr.expression) {
+          return true;
+        }
+      }
+
+      return false;
+    })
+
+    return !tags.includes(element.tag) || !isDataSourceConfigured();
+  }
+
   @withSourceMap()
   toNaturalTS(state = createCompilerState(), parentLevel?: number): string {
     let code = '';
@@ -2306,6 +2382,7 @@ export class ViewElement extends Annotatable {
               }),
               // levelIndex,
             );
+            code += ',\n';
           });
 
           code += `${indent(state.tabSize + 1)}] },\n`;
@@ -2315,15 +2392,16 @@ export class ViewElement extends Annotatable {
       });
       // 翻译其余的子集
       if (defaultArr.length) {
-        throw new Error('多个插槽必须都在 template 内');
-        // defaultArr.forEach((element) => {
-        //   code += element.toTextualNASL(
-        //     shiftState(state, code, {
-        //       tabSize: state.tabSize,
-        //     }),
-        //     // levelIndex,
-        //   );
-        // });
+        // throw new Error('多个插槽必须都在 template 内');
+        defaultArr.forEach((element) => {
+          code += element.toTextualNASL(
+            shiftState(state, code, {
+              tabSize: state.tabSize,
+            }),
+            // levelIndex,
+          );
+          code += ',\n';
+        });
       }
     } else {
       if (this.children.length) {
@@ -3079,7 +3157,7 @@ export class ViewElement extends Annotatable {
           })
         }
         if (
-          options?.isExport &&
+          (options?.isExport  || options?.isRelease )&&
           attr?.concept === 'BindAttribute' &&
           attr?.name === 'src' &&
           /^\/assets\/(.*?)$/.test(attr?.value) &&
@@ -3119,7 +3197,6 @@ export class ViewElement extends Annotatable {
             argsList,
             dataRefList,
           };
-          // debugger
           // 所有参数序列化之后当字符串传进指令参数 （目前不支持<div v-demo="{ color: 'white', text: 'hello!' }"></div>
           let expression = StringLiteral.from({
             concept: 'StringLiteral',
@@ -3150,22 +3227,24 @@ export class ViewElement extends Annotatable {
         ve?.bindAttrs?.find((attr: any) => {
           let type = attr?.expression?.object?.__TypeAnnotation;
           if (type) {
-            console.log('type: ', type);
             let { typeKind, typeName, typeNamespace } = type || {};
-            // todo 这里可能不是匿名数据结构吗
-            if (typeKind === 'anonymousStructure') {
+             if (typeKind === 'anonymousStructure') {
               let parent: any =
                 this.getAncestorByTag('ViewElement', 'u-table-view') ||
                 this.getAncestorByTag('ViewElement', 'u-list-view') ||
                 this.getAncestorByTag('ViewElement', 'u-grid-view') ||
                 this.getAncestorByTag('ViewElement', 'van-grid-view') ||
                 this.getAncestorByTag('ViewElement', 'van-list-view');
-              if (parent?.tag) {
+                let canAdd = parent?.tag
+                if(isGridViewLayout ||isListViewLayout){
+                  let nestLinearLayout = this.children.find(c=>c.tag ==='u-linear-layout')
+                  canAdd = canAdd && !nestLinearLayout
+                }
+              if (canAdd) {
                 let dataSourceAttr = parent?.bindAttrs?.find((it: any) => it?.name === 'dataSource');
                 if (dataSourceAttr?.expression?.concept === 'CallLogic') {
                   if (dataSourceAttr?.expression?.calleeNamespace === 'app.logics') {
                     logicName = dataSourceAttr?.expression?.calleeName;
-                    //  debugger
                     let ref = {
                       typeNamespace: 'app.logics',
                       typeName: logicName,
@@ -3202,11 +3281,15 @@ export class ViewElement extends Annotatable {
       const addDataRefDriective = (ve: ViewElement) => {
         ve?.bindAttrs?.find((attr: any) => {
           let type = attr?.expression?.object?.__TypeAnnotation;
-          if (type) {
+          let canAdd = type
+          if(isGridViewLayout || isListViewLayout){
+            let nestLinearLayout = this.children.find(c=>c.tag ==='u-linear-layout')
+            canAdd = canAdd && !nestLinearLayout
+          }
+        if (canAdd) {
             let { typeKind, typeName, typeNamespace } = type || {};
             if (typeKind === 'reference' && typeNamespace) {
               let entityPropName = attr?.expression?.property?.name;
-              // debugger;
               let ref = {
                 typeNamespace,
                 typeName,

package/src/concepts/View__.ts

@@ -31,6 +31,8 @@ import type Interface from './Interface__'; // 临时记录删除的页面元素
 import { getNodeByNodeCallee } from '../automate/engine/utils.js'; // 临时记录删除的页面元素计数的最大值
 import type LogicItem from './LogicItem__';
 import type CallFunction from './CallFunction__';
+import type BaseNode from '../common/BaseNode';
+import type SubLogic from './SubLogic__';
 
 import App from './App__';
 import Module from './Module__';
@@ -1661,6 +1663,93 @@ export class View extends Annotatable {
     }
   }
 
+  mergeDefinitions2(code: string) {
+    const Logic = getConceptConstructor('Logic');
+    const Param = getConceptConstructor('Param');
+    const Variable = getConceptConstructor('Variable');
+    const BindEvent = getConceptConstructor('BindEvent');
+    const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
+    const definition: any = JSON.parse(definitionStr);
+     // 服务端逻辑
+     if (Array.isArray(definition.logics)) {
+      definition.logics.forEach((logicOption: any) => {
+        const logic = Logic.from(
+          {
+            ...logicOption,
+          },
+          this.rootNode,
+          'logics',
+        );
+        (this.rootNode as App).addLogic(logic);
+      });
+    }
+
+    // 全局结构体
+    if (Array.isArray(definition.structures)) {
+      definition.structures.forEach((structureOption: any) => {
+        const structure = Structure.from(
+          {
+            ...structureOption,
+          },
+          this.rootNode,
+          'structures',
+        );
+        (this.rootNode as App).addStructure(structure);
+      });
+    }
+
+    // 页面入参
+    if (Array.isArray(definition.viewParams)) {
+      definition.viewParams.forEach((paramsOption: any) => {
+        const param = Param.from(
+          {
+            ...paramsOption,
+          },
+          this,
+          'params',
+        );
+        this.addParam(param);
+      });
+    }
+    // 页面变量
+    if (Array.isArray(definition.viewVariables)) {
+      definition.viewVariables.forEach((variableOption: any) => {
+        const variable = Variable.from(
+          {
+            ...variableOption,
+          },
+          this,
+          'variables',
+        );
+        this.addVariable(variable);
+      });
+    }
+
+    // 页面事件
+    if (Array.isArray(definition.viewBindEvents)) {
+      definition.viewBindEvents.forEach((eventOption: any) => {
+        const newLogic = definition.viewLogics.find((logic: Logic) => eventOption.calleeName === logic.name);
+        const bindEvent = this.bindEvents.find((currentEventItem) => currentEventItem.name === eventOption.name);
+
+        // 如果没有event对象就先新增一个，如果已经有了就在内部添加logic
+        if (!bindEvent) {
+          const event = BindEvent.from(
+            {
+              ...eventOption,
+              calleeName: '',
+              logics: [newLogic],
+            },
+            this,
+            'bindEvents',
+          );
+          this.addBindEvent(event);
+        } else {
+          bindEvent.addLogic(newLogic);
+        }
+      });
+    }
+  }
+
   onChange($event?: EventPayload): void {
     this.emit('change', $event);
   }
@@ -1788,7 +1877,8 @@ export class View extends Annotatable {
         };\n`;
     code += keyboardEventMixinCode;
     const processDetailFrom: ViewElement = this.getViewProcessForm(),
-      hasProcessDetailFrom = !!processDetailFrom, processV2 = this.getDestinationProcessV2();
+      hasProcessDetailFrom = !!processDetailFrom,
+      processV2 = this.getDestinationProcessV2();
     if (hasProcessDetailFrom) {
       const processDetailFromMixinCode = `const processDetailFromMixin = {
         data() {
@@ -1874,13 +1964,7 @@ export class View extends Annotatable {
                 }
               },
               methods:{
-                // 将vmRoot的方法名包含handleDataSourceLoad的方法挂载到当前vm实例上
-                ...Object.keys(vmRoot).reduce((acc, cur) => {
-                  if (cur.includes('handleDataSourceLoad')) {
-                    acc[cur] = vmRoot[cur]
-                  }
-                  return acc
-                }, {}),
+                ..._self.$options.methods
               }
             }).$mount()
             var parentElement = container.parentNode
@@ -2095,6 +2179,8 @@ export class View extends Annotatable {
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
+    // 获取所有子节点用于树上填充
+    self.getSubLogics();
     function chineseTsName(name: string) {
       let tsName = name;
       // 匹配所有特殊字符都转为_
@@ -2131,6 +2217,9 @@ export class View extends Annotatable {
           // 内置函数对集合类型的推导
           (asserts.isCallFunction(el) && el.derivablecollection?.name))
       ) {
+        if (el?.getAncestor('SubLogic')) {
+          return;
+        }
         // 子页面内部逻辑过滤
         if (el.view !== self) return;
         if (asserts.isAssignment(el)) {
@@ -2789,6 +2878,10 @@ export class View 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', '');
+    }
 
     // view 局部变量，申明提升前增加判断，使用 logic 内的 result 直接替换成对应 logic，logic 内部变量替换成 null
     if (logicRtn && code.includes(logicRtn.name)) {
@@ -2965,6 +3058,54 @@ export class View extends Annotatable {
     };
   }
 
+  subLogics: Array<SubLogic> = [];
+
+  getSubLogics() {
+    const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
+      if (asserts.isSubLogic(node)) {
+        // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
+        if (node?.getAncestor('Logic')) {
+          return false;
+        }
+        return true;
+      }
+    });
+    this.subLogics = subLogics as Array<SubLogic>;
+  }
+
+  existingSubLogic: Set<string> = new Set<string>();
+
+  collectExistSubLogic() {
+    const existSubLogics: SubLogic[] = [];
+    this.findNaslNodeByBFS((node: BaseNode) => {
+      if (asserts.isSubLogic(node)) {
+        existSubLogics.push(node);
+      }
+      return false;
+    });
+    return existSubLogics;
+  }
+
+  // 获取当前逻辑中已经存在的子逻辑名称
+  getSubLogicExistingNames(excludedList: Array<SubLogic> = []) {
+    if (!this.existingSubLogic.size) {
+      const subLogics = this.collectExistSubLogic();
+      subLogics.forEach((subLogic) => {
+        if (!excludedList.includes(subLogic)) {
+          this.existingSubLogic.add(subLogic.name);
+        }
+      });
+    }
+    return Array.from(this.existingSubLogic);
+  }
+
+  getSubLogicUniqueName(name = 'subLogic1', excludedNames: Array<string> = []) {
+    const existingNames = this.getSubLogicExistingNames();
+    const uniqueName = utils.unique(name, existingNames.concat(excludedNames), undefined, false);
+    this.existingSubLogic.add(uniqueName);
+    return uniqueName;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -3485,6 +3626,14 @@ export const ComponentCompletionPropertyMap: Record<string, any> = {
       state: 'currentData',
       label: '数据',
     },
+    order: {
+      prop: 'sorting',
+      label: '排序方式',
+    },
+    filter:{
+      prop:'filter',
+      label:'筛选条件'
+    },
   },
   List: {
     current: {

package/src/concepts/basics/stdlib/nasl.processV2.ts

@@ -205,7 +205,7 @@ export function initialize() {
         }),
         new StructureProperty({
           name: 'procInstStatus',
-          typeAnnotation: TypeAnnotation.createReference('ProcInstStatusEnum', { typeNamespace: 'nasl.processV2' }),
+          typeAnnotation: TypeAnnotation.createReference('ProcInstStatusEnum', { typeNamespace: 'nasl.processV2.enums' }),
         }),
         new StructureProperty({
           name: 'procInstCurrNodes',
@@ -220,7 +220,7 @@ export function initialize() {
       ],
     }),
     new Structure({
-      name: 'getTaskOperationPermission',
+      name: 'TaskOperationPermission',
       properties: [
         new StructureProperty({
           name: 'name',

package/src/concepts/basics/stdlib/nasl.ui.ts

@@ -525,7 +525,7 @@ export function initialize() {
       ],
     }),
     new Structure({
-      name: 'ValidateEvent',
+      name: 'ValidateResult',
       properties: [
         new StructureProperty({
           name: 'rawValue',