@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/src/concepts/Theme__.ts

@@ -46,6 +46,15 @@ export class Theme extends BaseNode {
     [name: string]: string;
   } = {};
 
+  /**
+   * scope
+   * 主题变量 Map
+   */
+  @property({
+    objectRef: '',
+  })
+  scopeVariableMap: { [scope: string]: { [key: string]: string } } = {};
+
   /**
    * @param source 需要合并的部分参数
    */

package/src/concepts/Transactional__.ts

@@ -111,11 +111,6 @@ export class Transactional extends BaseNode {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
-  @withSourceMap()
-  toNaturalTS(state = createCompilerState()): string {
-    return '';
-  }
-
   /**
    * 祖先 Logic
    */

package/src/concepts/TriggerLauncher__.ts

@@ -13,7 +13,7 @@ import LogicItem from './LogicItem__';
 
 import App from './App__';
 import Module from './Module__';
-import ConnectorTriggerLauncher from './ConnectorTriggerLauncher__';
+import type ConnectorTriggerLauncher from './ConnectorTriggerLauncher__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/TypeAnnotation__.ts

@@ -965,6 +965,23 @@ export class TypeAnnotation extends BaseNode {
       code += `__name: "AStructure_${self.hash}" `;
       code += ' }';
       return code;
+    } else if (self?.typeKind === 'function') {
+      let code = '';
+      code += '(';
+      const paramTypes = self?.typeArguments || [];
+      yield* wrapForEach(paramTypes, function* warpForEachGenerator(type, index) {
+        code += `param${index + 1}:${yield* type.toEmbeddedTS(shiftState(state, code))}`;
+        if (index !== paramTypes.length - 1) {
+          code += ',';
+        }
+      });
+      code += ')';
+      code += '=>';
+      const returnTypes = self?.returnType || [];
+      yield* wrapForEach(returnTypes, function* warpForEachGenerator(type) {
+        code += yield* type.toEmbeddedTS(shiftState(state, code));
+      });
+      return code;
     } else {
       if (self.tsCalleeNamespace && self.typeName) {
         return `${self.tsCalleeNamespace}.${self.typeName}`;

package/src/concepts/TypeParam__.ts

@@ -69,6 +69,9 @@ export class TypeParam extends BaseNode {
   // 使用什么组件
   useComponent: any = undefined;
 
+  // 需要选择泛型，不能推导
+  needChoose: boolean;
+
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState(), prefix?: string): TranslatorGenerator {
     const self = this;

package/src/concepts/ValidationRule__.ts

@@ -270,7 +270,12 @@ export class ValidationRule extends LogicItem {
   //================================================================================
 
   public static getDefaultOptions() {
-    return {};
+    return {
+      target: {
+        concept: 'Identifier',
+        name: '',
+      },
+    };
   }
 
   toInViewMethod() {

package/src/concepts/ViewElement__.ts

@@ -16,6 +16,9 @@ import * as babelParser from '@babel/parser';
 import * as json5 from 'json5';
 import * as compiler from 'vue-template-compiler';
 
+import { Namespace } from './Namespace__';
+import { BooleanLiteral } from './BooleanLiteral__';
+import { StringLiteral } from './StringLiteral__';
 import { LogicItem } from './LogicItem__';
 import { Logic } from './Logic__';
 import { config } from '../config';
@@ -76,6 +79,7 @@ function genArgumentMemberExpression(arr: string[]) {
   return expressionNode;
 }
 export interface ElementToVueOptions {
+  filterAttr?:  Array<string>;
   isExport?: boolean;
   isRoot?: boolean;
   asCompontent?: boolean;
@@ -101,14 +105,7 @@ function transAstNodeToNaslNode(astNode: any, namespace?: string): any {
   let node = null;
   if (astNode.type === 'CallExpression' && astNode.callee.object.name === '$utils') {
     const calleeName = astNode.callee.property.name || astNode.callee.property.value;
-    node = {
-      concept: 'CallFunction',
-      name: '',
-      label: '调用内置函数',
-      kind: 'Expression',
-      calleeNamespace: 'nasl.util',
-      calleeName,
-      arguments: astNode.arguments
+    const _arguments = astNode.arguments
         .map((argument: any) => ({
           concept: 'Argument',
           name: '',
@@ -117,10 +114,24 @@ function transAstNodeToNaslNode(astNode: any, namespace?: string): any {
           expression: transAstNodeToNaslNode(Object.assign({}, argument)),
         }))
         .filter((item: any) => item.expression),
-      typeArguments: astNode.arguments
-        .map((argument: any) => transAstNodeToNaslTypeNode(Object.assign({}, argument)))
-        .filter((item: any) => item),
+        _typeArguments = astNode.arguments.map((argument: any) => transAstNodeToNaslTypeNode(Object.assign({}, argument))).filter((item: any) => item);
+    node = {
+      concept: 'CallFunction',
+      name: '',
+      label: '调用内置函数',
+      kind: 'Expression',
+      calleeNamespace: 'nasl.util',
+      calleeName,
+      arguments: _arguments,
+      typeArguments: _typeArguments,
     };
+
+    if ( calleeName === 'Convert') {
+      node.arguments = [_arguments[0]];
+      if (_typeArguments.length === 0 && _arguments?.length === 2) {
+        node.typeArguments = [_arguments?.[1].expression];
+      }
+    }
   } else if (astNode.type === 'MemberExpression') {
     if (astNode.object?.name === '$global') {
       if (astNode.property?.name === 'userInfo') {
@@ -154,12 +165,21 @@ function transAstNodeToNaslNode(astNode: any, namespace?: string): any {
       name: astNode.name,
       kind: 'Expression',
     };
-  } else if (astNode.type === 'ArrayExpression' || astNode.type === 'ObjectExpression') {
+  } else if (astNode.type === 'ArrayExpression') {
     node = {
       concept: 'Unparsed',
       label: '原子项',
       code: astNode.value,
     };
+  } else if (astNode.type === 'ObjectExpression') {
+    const properties = astNode.properties.map((property: any) => ({
+      key: property.key.value,
+      value: property.value.value,
+    }));
+    node = {};
+    properties.forEach((property: any) => {
+      node[property.key] = property.value;
+    })
   } else if (astNode.type === 'TemplateLiteral') {
     // 模板字符串翻译成字符串插值
     const { expressions, quasis } = astNode;
@@ -303,17 +323,18 @@ import * as utils from '../utils';
 import { createUUID } from '../utils/create';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
-import BaseNode from '../common/BaseNode';
+
 import BindAttribute from './BindAttribute__';
 import BindEvent from './BindEvent__';
 import BindDirective from './BindDirective__';
 import BindStyle from './BindStyle__';
+import Annotatable from './Annotatable__';
 
 /**
  * 页面元素
  */
 @concept('页面元素')
-export class ViewElement extends BaseNode {
+export class ViewElement extends Annotatable {
   /** 类名 */
   static readonly ConceptName: string = 'ViewElement';
   /**
@@ -322,7 +343,7 @@ export class ViewElement extends BaseNode {
    */
   static isAbstract: boolean = false;
   /** 继承链 */
-  static readonly inheritanceChain: string[] = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['Annotatable', 'BaseNode'];
 
   /**
    * 产品概念
@@ -336,6 +357,12 @@ export class ViewElement extends BaseNode {
   @property()
   tag: string;
 
+  /**
+   * 命名空间
+   */
+  @property()
+  refNamespace?: string;
+
   /**
    * 页面元素名称
    */
@@ -2279,7 +2306,6 @@ export class ViewElement extends BaseNode {
               }),
               // levelIndex,
             );
-            code += ',\n';
           });
 
           code += `${indent(state.tabSize + 1)}] },\n`;
@@ -2289,16 +2315,15 @@ export class ViewElement extends BaseNode {
       });
       // 翻译其余的子集
       if (defaultArr.length) {
-        // throw new Error('多个插槽必须都在 template 内');
-        defaultArr.forEach((element) => {
-          code += element.toTextualNASL(
-            shiftState(state, code, {
-              tabSize: state.tabSize,
-            }),
-            // levelIndex,
-          );
-          code += ',\n';
-        });
+        throw new Error('多个插槽必须都在 template 内');
+        // defaultArr.forEach((element) => {
+        //   code += element.toTextualNASL(
+        //     shiftState(state, code, {
+        //       tabSize: state.tabSize,
+        //     }),
+        //     // levelIndex,
+        //   );
+        // });
       }
     } else {
       if (this.children.length) {
@@ -3035,12 +3060,24 @@ export class ViewElement extends BaseNode {
     this.refName && parts.push(`:ref="\`${this.refName}\`"`);
     this.keyName && parts.push(`:key="\`${this.keyName}\`"`);
     this.staticClass && parts.push(`class="${this.staticClass}"`);
+    let dataRefList: any[] = [];
 
     const vIfs: string[] = [];
     []
       .concat(this.bindAttrs, this.bindDirectives, this.bindEvents)
       .forEach((attr: BindAttribute | BindDirective | BindEvent) => {
         let result = newOptions.attrFormat(attr, this, attr?.toVue(newOptions));
+         // 属性翻译为指令 ：仅封闭态流程表单内使用
+        if(options?.filterAttr
+          && options?.filterAttr?.length>0
+          && attr.concept === 'BindAttribute'
+          && attr.name === 'processHidden'){
+          options?.filterAttr.map(filterAttrName=>{
+            if(attr.name===filterAttrName){
+              result = null
+            }
+          })
+        }
         if (
           options?.isExport &&
           attr?.concept === 'BindAttribute' &&
@@ -3059,8 +3096,143 @@ export class ViewElement extends BaseNode {
 
           return;
         }
+
         result && parts.push(result);
       });
+    const genDirectiveByAnno = (viewElement: ViewElement) => {
+      if (viewElement?.applyAnnotations?.length > 0) {
+        // todo: 根据注解生成自定义指令 v-annoName="context"
+        // 血缘算法要生成一个所有的 Entity-ViewElement 的映射map
+        // context 从 血缘算法映射获取 getRelataionByElement()
+        return viewElement.applyAnnotations.map((aa) => {
+          const getExpressionValue = (expression: any) => {
+            if (expression?.concept === 'BooleanLiteral') {
+              return BooleanLiteral.from(expression)?.toBoolean();
+            }
+            if (expression?.concept === 'NewList') {
+              return eval(expression.toUI().replace('新建：', ''));
+            }
+            return expression?.value;
+          };
+          let argsList = aa.arguments.map((arg: any) => getExpressionValue(arg.expression));
+          let annoArgs = {
+            argsList,
+            dataRefList,
+          };
+          // debugger
+          // 所有参数序列化之后当字符串传进指令参数 （目前不支持<div v-demo="{ color: 'white', text: 'hello!' }"></div>
+          let expression = StringLiteral.from({
+            concept: 'StringLiteral',
+            kind: 'Expression',
+            name: '',
+            value: JSON.stringify(annoArgs),
+          });
+          let annoDirective = BindDirective.from({
+            name: aa.annotationName,
+            // arg:'arg',
+            expression,
+          });
+          return annoDirective;
+        });
+      }
+    };
+    let isH5ListViewLayout = this?.tag === 'van-cell' && this.getAncestorByTag('ViewElement', 'van-list-view');
+    let isListViewLayout = this?.tag === 'u-linear-layout' && this.getAncestorByTag('ViewElement', 'u-list-view');
+    let isGridViewLayout = this?.tag === 'u-linear-layout' && this.getAncestorByTag('ViewElement', 'u-grid-view');
+
+    const getLogicDataRef = (viewElement: ViewElement) => {
+      //  自上向下查找,  指令需要翻译到绑定值元素的上级父元素
+      // 这个元素需要满足 1 向下能找到 绑定了值的表单子元素
+      // 2 向上能找到 固定的几种表单元素 且带有dataSource 并找到对应的calllogic name
+      let targetTag = ['u-table-view-column']; //'u-form-item' 逻辑无法感知到表单绑定值的变更
+      let logicName;
+      const addDataRefDriective = (ve: ViewElement) => {
+        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') {
+              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 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,
+                      propName: attr?.expression.toUI()?.replace('current.item.', ''),
+                    };
+                    console.log('ref: ', ref);
+                    dataRefList.push(ref);
+                    // 要考虑 多个元素 每个元素有多个注解的情况
+                    let result = (genDirectiveByAnno(viewElement) as any)?.map((d: any) => d?.toVue());
+                    result && result?.length > 0 && parts.push(...result);
+                  }
+                }
+              }
+            }
+          }
+        });
+      };
+      // 特殊的 'van-text' 'van-grid-view' 默认没有线性布局包裹 文本
+      if (viewElement?.tag === 'van-text') {
+        addDataRefDriective(viewElement);
+      }
+      if (targetTag.includes(viewElement?.tag) || isH5ListViewLayout || isGridViewLayout || isListViewLayout) {
+        this.traverseChildren((ve: ViewElement) => {
+          addDataRefDriective(ve);
+        });
+      }
+    };
+    // 已知问题: 逻辑的表格可以推导 表单无法推导(如果是实体拖过来的 还是指向实体)
+    // 已知问题: 目前采用隐藏父元素的方式; 后续有任何 tag 或者结构更改都不生效
+    getLogicDataRef(this);
+    const getEntityDataRef = (viewElement: ViewElement) => {
+      // 这个类型都是 默认找到子元素的数据引用  然后加到自己的指令上
+      let targetTag = ['u-table-view-column', 'u-form-item'];
+      const addDataRefDriective = (ve: ViewElement) => {
+        ve?.bindAttrs?.find((attr: any) => {
+          let type = attr?.expression?.object?.__TypeAnnotation;
+          if (type) {
+            let { typeKind, typeName, typeNamespace } = type || {};
+            if (typeKind === 'reference' && typeNamespace) {
+              let entityPropName = attr?.expression?.property?.name;
+              // debugger;
+              let ref = {
+                typeNamespace,
+                typeName,
+                propName: entityPropName,
+              };
+              dataRefList.push(ref);
+              let result = (genDirectiveByAnno(viewElement) as any)?.map((d: any) => d?.toVue());
+              result && result?.length > 0 && parts.push(...result);
+            }
+            // typeName "Entity1"
+            // typeNamespace "app.dataSources.defaultDS.entities"
+          }
+        });
+      };
+      // 特殊的 'van-text' 'van-grid-view' 默认没有线性布局包裹 文本
+      if (viewElement?.tag === 'van-text') {
+        addDataRefDriective(viewElement);
+      }
+      if (targetTag.includes(viewElement?.tag) || isH5ListViewLayout || isGridViewLayout || isListViewLayout) {
+        this.traverseChildren((ve: ViewElement) => addDataRefDriective(ve));
+      }
+      // 数据网格: 指令单元是线性布局 (数据列表结构也一样)
+      // 1 向下能找到 一个绑定了数据源的元素
+      // 2 向上是线性布局 卡片 template gridView
+    };
+    getEntityDataRef(this);
 
     if (vIfs.length === 2) parts.push(`v-if="(${vIfs[0]}) && (${vIfs[1]})"`);
     else if (vIfs.length === 1) parts.push(`v-if="${vIfs[0]}"`);
@@ -3133,6 +3305,21 @@ export class ViewElement extends BaseNode {
       staticStyle = staticStyle.replace(/url\('\/assets\/(.*?)'\)/, `url('${this.app.sysPrefixPath}/assets/$1')`);
     }
     staticStyle && parts.push(`style="${staticStyle}"`);
+     // input hidden属性 要翻译到上级元素的 栅格列的if指令
+    // 从父查子 若有hidden 直接输出null
+    if(this?.name?.includes('grid_layout_column')
+       &&!(options?.filterAttr && options?.filterAttr?.length>0)){
+      let checkHiddenAttr =(it:any) => it?.bindAttrs?.find((attr:any)=> attr?.name === 'processHidden')
+      let getHiddenChild = (el:any)=>{
+        return el.children?.find((it:any)=>{
+          return it.children?.find((item:any)=>checkHiddenAttr(item) )
+          //return checkHiddenAttr(it)
+          })
+      }
+      if(getHiddenChild(this)){
+        parts.push(`v-show="window.Vue.prototype.$env.VUE_APP_DESIGNER"`)
+      }
+    }
     if (!content.length) {
       shouldIndent = false;
     }
@@ -3163,14 +3350,7 @@ export class ViewElement extends BaseNode {
    * 从父级删除该节点
    * @internal
    */
-  delete() {
-    super.delete();
-    if (this.parentNode) {
-      this.traverseChildren((ele: ViewElement) => {
-        (this.likeComponent as any)?.removeExistingViewElement(ele);
-      });
-    }
-  }
+  delete() {}
 
   findElementByName(name: string): ViewElement {
     return utils.traverse(
@@ -3414,6 +3594,16 @@ export class ViewElement extends BaseNode {
       this.getBindAttribute('processPrefix')
     );
   }
+  getAncestorByTag<Node extends types.SyntaxNode = types.SyntaxNode>(
+    concept: types.SyntaxNode['concept'],
+    tag: string,
+  ): Node {
+    let parentNode = this?.parentNode;
+    while (parentNode && parentNode.concept && !(parentNode.concept === concept && (parentNode as any)?.tag === tag)) {
+      parentNode = parentNode.parentNode;
+    }
+    return parentNode as Node;
+  }
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓