@lcap/nasl 3.6.0-alpha.1 → 3.6.0-alpha.2

package/src/bak/translator.js

@@ -4,24 +4,103 @@ function safeCodeAsKey(name) {
   return `['${name}']`;
 }
 
-function tryJSONParse(str) {
-  let result;
+/**
+ * 获取变量初始值
+ * @param {*} variable
+ * @param {*} URLParamRetrieval 从地址栏获取
+ * @returns
+ */
+function genVarInitialVal(variable, URLParamRetrieval) {
+  const typeAnnotation = variable.typeAnnotation || variable.__TypeAnnotation;
+  let { typeKind, typeNamespace, typeName, sortedTypeKey } = typeAnnotation || {};
+  if (typeNamespace?.endsWith('.metadataTypes')) {
+    const referenceNode = variable.getAncestor('App').findNodeByCompleteName(typeNamespace + '.' + typeName) || {}
+    const typeAn = referenceNode.typeAnnotation || {};
+    typeKind = typeAn.typeKind;
+    typeNamespace = typeAn.typeNamespace;
+    typeName = typeAn.typeName;
+    sortedTypeKey = `${typeNamespace}.${typeName}`;
+  }
+  const needGenInitFromSchema =
+      typeAnnotation && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
 
-  try {
-    result = JSON.parse(str);
-  } catch (e) { }
+  let code = '';
+  if (needGenInitFromSchema) {
+    code += `this.$genInitFromSchema('${sortedTypeKey}', `;
+  }
+  if (variable.concept === 'Param' && URLParamRetrieval) {
+    code += `this.$route.query.hasOwnProperty('${variable.name}') ? this.$genInitFromSchema('${sortedTypeKey}', this.$route.query.${variable.name}) :`;
+  }
+  const { defaultValue } = variable;
+  // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
+  const parsedValue = defaultValue?.expression?.toJS?.() ?? undefined;
 
-  return result;
+  code += parsedValue;
+  if (needGenInitFromSchema) {
+    code += `)`;
+  }
+  return code;
+}
+
+/**
+ * 获取组件入参的类型
+ * @param {*} typeAnnotation
+ */
+function getPropsType(typeAnnotation) {
+  let type = 'Object';
+  const { typeKind, typeNamespace, typeName, typeArguments } = typeAnnotation || {};
+  if (
+    typeKind === 'union'
+    && typeNamespace === 'nasl.core'
+    && typeName === 'Union'
+    && Array.isArray(typeArguments)
+    && typeArguments.length
+  ) {
+    const arr = typeArguments.map((typeArgument) => {
+      return getPropsType(typeArgument);
+    });
+    type = `[${arr.join(', ')}]`;
+  } else {
+    if (typeKind === 'primitive' && typeNamespace === 'nasl.core') {
+      const typeMap = {
+        Boolean: 'Boolean',
+        Decimal: 'Number',
+        Long: 'Number',
+        String: 'String',
+        Date: 'String',
+        Time: 'String',
+        DateTime: 'String',
+      };
+      if (typeMap[typeName]) {
+        type = typeMap[typeName];
+      }
+    } else if (typeKind === "generic" && typeNamespace === "nasl.collection" && typeName === 'List') {
+      type = 'Array';
+    }
+  }
+  return type;
 }
 
 export default function (definition, view) {
+  let isBusinessComponent = false;
+  if (view.concept === 'BusinessComponent') {
+    isBusinessComponent = true;
+  }
   /**
    * 页面的 data
    * 包含 页面变量 / 页面入参 / 页面元素绑定的表达式的返回
    */
   const viewVariablesData = [];
+  // 组件入参
+  const viewProps = [];
   // 所有的页面变量
-  const viewVariables = [...(definition.params || []), ...(definition.variables || [])];
+  const viewVariables = [...(definition.variables || [])];
+  if (isBusinessComponent) {
+    viewProps.push(...(definition.params || []));
+  } else {
+    viewVariables.push(...(definition.params || []));
+  }
+
   // 页面元素绑定的表达式
   const { viewExpressions } = definition;
   const hasViewExpressions = Array.isArray(viewExpressions) && viewExpressions.length;
@@ -29,38 +108,8 @@ export default function (definition, view) {
    * genInitFromSchema 是为了将数据类型的处理和页面逻辑的生成分开
    * 比如 param a.b 的 schema 有变化，View 代码无需再次生成
    */
-  const dataMap = {};
   viewVariables.forEach((viewVariable) => {
-    dataMap[viewVariable.code || viewVariable.name] = true;
-    const typeAnnotation = viewVariable.typeAnnotation || viewVariable.__TypeAnnotation;
-    let { typeKind, typeNamespace, typeName, sortedTypeKey } = typeAnnotation || {};
-    if (typeNamespace?.endsWith('.metadataTypes')) {
-      const referenceNode = view.getAncestor('App').findNodeByCompleteName(typeNamespace + '.' + typeName) || {}
-      const typeAn = referenceNode.typeAnnotation || {};
-      typeKind = typeAn.typeKind;
-      typeNamespace = typeAn.typeNamespace;
-      typeName = typeAn.typeName;
-      sortedTypeKey = `${typeNamespace}.${typeName}`;
-    }
-    const needGenInitFromSchema =
-      typeAnnotation && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
-    let code = `${safeCodeAsKey(viewVariable.name)}:`;
-    if (needGenInitFromSchema) {
-      code += `this.$genInitFromSchema('${sortedTypeKey}', `;
-    }
-    if (viewVariable.concept === 'Param') {
-      code += `this.$route.query.hasOwnProperty('${viewVariable.name}') ? this.$genInitFromSchema('${sortedTypeKey}', this.$route.query.${viewVariable.name}) :`;
-    }
-
-    const { defaultValue } = viewVariable;
-    // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
-    const parsedValue = defaultValue?.expression?.toJS?.() ?? undefined;
-
-    code += parsedValue;
-    if (needGenInitFromSchema) {
-      code += `)`;
-    }
-    viewVariablesData.push(code);
+    viewVariablesData.push(`${safeCodeAsKey(viewVariable.name)}: ${genVarInitialVal(viewVariable, !isBusinessComponent)}`);
   });
   /**
    * 页面的 computed
@@ -152,7 +201,9 @@ export default function (definition, view) {
 
   const events = Array.from(eventMap).map(([name, bindEvents]) => {
     let code = `async ${name} () {
-        ${bindEvents.map((event) => `await this.${event.view.name}_${event.name}();`).join('\n')}`;
+      ${bindEvents.map((event) =>{
+        const likeComponent = event.view || event.getAncestor('BusinessComponent');
+        return `await this.${likeComponent?.name}_${event.name}();`}).join('\n')}`;
     code += '}';
     return code;
   });
@@ -167,15 +218,42 @@ export default function (definition, view) {
       tabSize: 1,
     })
   );
-
-  const output = `
+  const viewPropArr = [];
+  // 监听
+  const watcherArr = [];
+  let output = '';
+  if (Array.isArray(viewProps) && viewProps.length) {
+    viewProps.forEach((viewProp) => {
+      const typeAnnotation = viewProp.typeAnnotation || viewProp.__TypeAnnotation;
+      viewPropArr.push(`${safeCodeAsKey(viewProp.name)}: {
+        type: ${getPropsType(typeAnnotation)},
+        default: ${genVarInitialVal(viewProp, !isBusinessComponent)}
+      }`);
+      watcherArr.push(`${safeCodeAsKey(viewProp.name)}: {
+        handler(val) {
+          this.$emit('update:${viewProp.name}', val);
+        },
+      }`);
+    });
+  }
+  if (Array.isArray(viewPropArr) && viewPropArr.length) {
+    output += `props: {
+      ${viewPropArr.join(',\n')}
+    },\n`;
+  }
+  if (Array.isArray(watcherArr) && watcherArr.length) {
+    output += `watch: {
+      ${watcherArr.join(',\n')}
+    },\n`;
+  }
+  output += `
         data() {
             return {
-                ${viewVariablesData.join(',\n').trim()}
+              ${viewVariablesData.join(',\n').trim()}
             };
         },
         computed: {
-            ${viewComputedData.join(',\n').trim()}
+          ${viewComputedData.join(',\n').trim()}
         },
 meta: {
     title: ${JSON.stringify(definition.title)},

package/src/breakpoint/generator/BreakpointNode.ts

@@ -349,6 +349,18 @@ export default class BreakpointNode extends BaseNode {
     return this.logic || this.variable;
   }
 
+  get items() {
+    return (this.node as any)?.items;
+  }
+
+  get concept() {
+    return (this.node as any)?.concept;
+  }
+
+  get getCallNode() {
+    return (this.node as any)?.getCallNode;
+  }
+
   init() {
     const source = this.logic || this.variable;
     const node = getRealNode(source);

package/src/breakpoint/shared/constants.ts

@@ -57,6 +57,7 @@ export const BREAKPOINT_CONCEPTS = [
   'Unparsed',
   'CallFunction',
   'CallLogic',
+  'CallEvent',
   'CallInterface',
   'CallConnector',
   'CallAuthInterface',

package/src/breakpoint/shared/utils.ts

@@ -3,6 +3,7 @@ import {
   View,
   BaseNode,
   ViewElement,
+  BusinessComponent,
 } from '../../concepts';
 
 import {
@@ -197,7 +198,7 @@ export const getLogics = (app: App) => {
     return [];
   }
 
-  const { frontends = [] } = app;
+  const { frontendTypes = [] } = app;
 
   let result = getGlobalLogics(app) || [];
 
@@ -220,7 +221,7 @@ export const getLogics = (app: App) => {
     viewElementChildren.forEach(forViewElement);
   };
 
-  const forView = (view: View) => {
+  const forView = (view: View | BusinessComponent) => {
     if (!view) {
       return;
     }
@@ -228,7 +229,6 @@ export const getLogics = (app: App) => {
     const {
       logics: viewLogics = [],
       elements: viewElements = [],
-      children: viewChildren = [],
       bindEvents: viewBindEvents = [],
     } = view;
 
@@ -241,13 +241,18 @@ export const getLogics = (app: App) => {
     });
 
     viewElements.forEach(forViewElement);
-    viewChildren.forEach(forView);
+    (view as View)?.children?.forEach(forView);
   };
 
-  frontends.forEach((frontend) => {
-    const { views = [] } = frontend;
-
-    views && views.forEach(forView);
+  frontendTypes.forEach((frontendType) => {
+    frontendType?.frontends?.forEach((frontend) => {
+      const { views = [] } = frontend;
+      views && views.forEach(forView);
+    });
+    const { businessComponents } = frontendType || {};
+    if (Array.isArray(businessComponents) && businessComponents.length) {
+      businessComponents.forEach(forView);
+    }
   });
 
   return result;

package/src/breakpoint/store/core.ts

@@ -138,7 +138,7 @@ const isFrontend = (node: BaseNode) => {
 
   const { getAncestor } = node;
 
-  return getAncestor && getAncestor.call(node, 'View');
+  return getAncestor && getAncestor.call(node, 'FrontendType');
 };
 
 const updateToBackend = (node: BaseNode) => {

package/src/common/BaseNode.ts

@@ -20,38 +20,6 @@ export function setActionable(value: boolean) {
   actionable = value;
 }
 
-// 确保属性都是定义过的
-function ensureDefined(object: any, concept: string) {
-  if (!object) {
-    return object;
-  }
-  const newObject: any = {};
-  const actualConcept = object?.concept || concept;
-  if (actualConcept) {
-    const propertyMap = getConceptPropertyMap(actualConcept);
-    for (const key in object) {
-      const property = propertyMap.get(key);
-      if (property) {
-        const objProperty = object[key] ?? null;
-        const propertyConcept = property?.objectRef;
-        if (propertyConcept) {
-          if (Array.isArray(objProperty)) {
-            newObject[key] = objProperty.map((objItem: any) => {
-              return ensureDefined(objItem, propertyConcept);
-            });
-          } else {
-            newObject[key] = ensureDefined(objProperty, propertyConcept);
-          }
-        } else {
-          newObject[key] = objProperty;
-        }
-      }
-    }
-
-    newObject.concept = actualConcept;
-  }
-  return newObject;
-}
 
 type NodePathOption = {
   useName?: boolean,
@@ -249,13 +217,6 @@ export class BaseNode extends EventEmitter {
   @property()
   composedBy?: Array<string>;
 
-
-  /**
-   * 分组管理在多人协作场景触点
-   */
-  @property()
-  composedOrigin?: 'Form' | 'Table' | 'Process';
-
   /**
    * 当前节点的类型标注
    */
@@ -1103,7 +1064,27 @@ export class BaseNode extends EventEmitter {
     });
     return JSON.parse(JSON.stringify(temp));
   }
-
+  // 给国际化展示用
+  getNodeChinesePath(useIndex: boolean | string[] | NodePathOption) {
+    let node: BaseNode = this;
+    const pathArr: string[] = [];
+    while (node && node.concept) {
+      let pathText = '';
+      const { parentNode } = node;
+      if (parentNode) {
+        const { name, title, label } = parentNode as any;
+        pathText = `${(parentNode.constructor as any)?.nodeTitle || ''}${name || ''}`;
+        if (title && label) {
+          pathText += `(${title} | ${label})`;
+        } else if (title || label) {
+          pathText += `(${title || label})`;
+        }
+        pathArr.unshift(pathText);
+      }
+      node = parentNode;
+    }
+    return pathArr.join('/');
+  }
   /**
    * 查找引用
    */
@@ -1496,7 +1477,7 @@ export class BaseNode extends EventEmitter {
     if (typeAnnotation) {
       const { typeKind, typeNamespace, typeName, properties } = typeAnnotation;
       if (typeKind === 'reference' || typeKind === 'generic') {
-        if (typeNamespace.endsWith('.enums')) return null;
+        if (typeNamespace?.endsWith('.enums')) return null;
         return [{}];
       }
       if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {

package/src/concepts/AnonymousFunction__.ts

@@ -649,27 +649,45 @@ export class AnonymousFunction extends LogicItem {
     return code;
   }
 
-  checkParamName() {
-    let node: types.SyntaxNode = this;
-    const names: Set<string> = new Set();
-    while (node && node.concept !== 'Logic') {
-      node = node.parentNode;
-      if (asserts.isAnonymousFunction(node)) {
-        node.params.forEach((param) => {
-          names.add(param.name);
-        });
+  /**
+   * 确保参数名称都是不重复的，且更新内部的引用关系
+   * @param paramNames
+   * @returns
+   */
+  ensureParamName(paramNames: Set<string>) {
+    const paramInfoMap = new Map<string, any>();
+    this.params.forEach((param) => {
+      const name = utils.unique(param.name, paramNames);
+      if (!paramInfoMap.get(param.name)) {
+        paramInfoMap.set(param.name, {});
       }
-
-      if (asserts.isForEachStatement(node)) {
-        names.add(node.item.name);
-        names.add(node.index.name);
+      const paramInfo = paramInfoMap.get(param.name);
+      // 即使没有修改，也需要把名字塞进去
+      paramInfo.newName = name;
+      if (name !== param.name) {
+        paramInfo.param = param;
+      }
+    });
+    this.traverseChildren((node) => {
+      if (node?.concept === 'Identifier') {
+        const parentNode = node.parentNode;
+        if (
+          parentNode?.concept !== 'MemberExpression'
+          || (parentNode.parentNode?.concept !== 'MemberExpression' && (parentNode as any).object === node)
+        ) {
+          if (node) {
+            const paramInfo = paramInfoMap.get(node.name);
+            if (paramInfo?.param) {
+              if (!Array.isArray(paramInfo?.identifiers)) {
+                paramInfo.identifiers = [];
+              }
+              paramInfo.identifiers.push(node);
+            }
+          }
+        }
       }
-    }
-
-    this.params.forEach((param) => {
-      const name = utils.unique(param.name, names);
-      param.name = name;
     });
+    return paramInfoMap;
   }
 
   //================================================================================