@lcap/nasl 3.8.0-beta.8 → 3.8.2-alpha.1

package/src/natural/index.ts

@@ -2,3 +2,4 @@ export * from './genNaturalTS';
 export * from './transformTSCode';
 export * from './transformTS2UI';
 export * from './getContext/getUILib';
+export * from './tools';

package/src/natural/tools.ts

@@ -0,0 +1,138 @@
+import { App, BaseNode } from "src/concepts";
+import * as utils from '../utils';
+
+// 获取当前逻辑的类型
+export const getLogicType = (activeLogic: any) => {
+  const { parentNode } = activeLogic || {};
+  let logicType = 'global_logic';
+  if (parentNode?.concept === 'View') {
+    logicType = 'view_logic';
+  } else if (parentNode?.concept === 'BindEvent') {
+    logicType = 'event_logic';
+  }
+  if (activeLogic?.concept === 'BusinessLogic') {
+    logicType = 'business_Logic';
+  }
+  return logicType;
+};
+
+// 获取所有未使用的 module
+export const getUsedModule = (json: BaseNode) => {
+  const useModule = [] as any;
+  const conceptMap = ['CallInterface', 'CallConnector', 'CallLogic'];
+  utils.traverse(({ node }: { node: any; }) => {
+    if (conceptMap.includes(node.concept)) {
+      if (/(apis\.|connector\.|extensions\.)/.test(node.calleeNamespace)) {
+        const symbol = node.calleeNamespace.match(/(\w+)(?=\.)|(\w+$)/g)[1];
+        const item = {
+          symbol,
+          key: symbol,
+          node,
+        } as any;
+        useModule.push(item);
+      }
+    }
+    if (node.concept === 'ViewElement' && node?.tag) {
+      const symbol = utils.kebab2Camel(node.tag);
+      const item = {
+        symbol,
+        key: symbol,
+        node,
+      } as any;
+      useModule.push(item);
+    }
+  }, { node: json }, { mode: 'anyObject' });
+  return useModule;
+};
+
+
+/**
+ * 根据生成的 NASL JSON，获取未导入的模块
+ * @param json: 当前生成的 NASL JSON
+ * @param app: 当前应用
+ * @param material: 召回的所有 Module
+ * @returns 需要导入的所有 Module 信息，包含 category、symbol、version
+ */
+export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material: any) => {
+  const useModule = getUsedModule(json);
+  const needImportModule = {
+    interfaces: new Map(),
+    connectors: new Map(),
+    library: new Map(),
+    extensionMaterials: new Map(),
+    needImportConnector: false
+  } as any;
+
+  useModule.forEach((item: any) => {
+    if (item.node.concept === 'CallInterface') {
+      // 从app.interfaceDependencies中找到对应的接口
+      const interfaceNode = app.interfaceDependencies?.find((node: any) => node.name === item.symbol);
+      if (!interfaceNode) {
+        item.category = 'interface';
+        const key = `${item.symbol}-${item?.node?.calleeName}`;
+        item.key = key;
+        needImportModule.interfaces.set(key, item);
+      }
+    } else if (item.node.concept === 'CallConnector') {
+      item.category = 'connector';
+      const connectorNode = app.connectorDependencies?.find((node: any) => node.name === item.symbol);
+
+      // 如果 连接器 不存在，则需要导入并初始化连接
+      if (!connectorNode) {
+        item.operator = 'importAndInit';
+        const curDep = material?.connectors?.find((node: any) => node.name === item.symbol)
+        item.version = curDep?.version;
+        item.provider = curDep?.provider || '资产中心';
+        needImportModule.needImportConnector = true;
+        needImportModule.connectors.set(item.symbol, item);
+      } else {
+        item.version = connectorNode.version;
+        // 查找连接
+        const connection = app.connections?.find((conn: any) => conn.connector.name === item.symbol);
+        // 如果 连接器 已存在，且连接已经被初始化过，需要修改生成 logic 中的名字，utils.traverse 修改
+        // 如果 连接器 已存在，且连接未被初始化过，则需要初始化连接
+        if (connection) {
+          item.operator = 'rename';
+          item.rename = { newName: connection.name, oldName: item.node.calleeConnectionName };
+        } else {
+          item.operator = 'init';
+          needImportModule.connectors.set(item.symbol, item);
+        }
+      }
+
+
+    } else if (item.node.concept === 'CallLogic') {
+      // 从app.logicDependencies中找到对应的逻辑
+      item.category = 'library';
+      const logicNode = app.dependencies?.find((node: any) => node.name === item.symbol);
+      if (!logicNode) {
+        const curDep = material?.dependencies?.find((node: any) => node.name === item.symbol);
+        item.version = curDep?.version;
+        item.provider = curDep?.provider || '资产中心';
+        needImportModule.library.set(item.symbol, item);
+      }
+    } else if (item.node.concept === 'ViewElement') {
+      const name = utils.kebab2Camel(item.node.tag);
+      const module = material?.extensionMaterials?.find((node: any) => utils.kebab2Camel(node.name) === name);
+      const imported = app.dependencies?.find((node: any) => node.name === module?.libraryName);
+      if (module && module.libraryName && !imported) {
+        const { libraryName } = module;
+        item.category = 'library';
+        item.key = `${libraryName}-${name}`;
+        item.symbol = libraryName;
+        const curDep = material?.dependencies?.find((node: any) => node.name === item.symbol);
+        item.version = curDep?.version;
+        item.provider = curDep?.provider || '';
+        needImportModule.extensionMaterials.set(name, item);
+      }
+    }
+  });
+
+  needImportModule.interfaces = Array.from(needImportModule.interfaces.values());
+  needImportModule.connectors = Array.from(needImportModule.connectors.values());
+  needImportModule.library = Array.from(needImportModule.library.values());
+  needImportModule.extensionMaterials = Array.from(needImportModule.extensionMaterials.values());
+
+  return needImportModule;
+};
+

package/src/natural/transformTS2UI.ts

@@ -413,7 +413,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
       });
     }
     if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
-      const entityName = callee[0].name.replace(/Entity$/, '');
+      const entityName = callee[0].name.replace(/Entity/, '');
       return new naslTypes.CallLogic({
         calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
         calleeName: (callee[1] as babelTypes.Identifier).name,
@@ -580,7 +580,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
     } else if (/^app.dataSources|app.logics/.test(calleeName)) {
       if (calleeName?.includes('.entities.')) {
         const calleeNamespace = generate((node?.callee as any)?.object?.object)?.code;
-        const entityName = (node?.callee as any)?.object?.property?.name?.replace(/Entity$/, '');
+        const entityName = (node?.callee as any)?.object?.property?.name?.replace(/Entity/, '');
         return new naslTypes.CallLogic({
           calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
           calleeName: (node?.callee as any)?.property?.name,
@@ -971,29 +971,55 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
 }
 
 // 处理逻辑
-function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string): naslTypes.Logic {
+function transformNode2Logic(node: babelTypes.FunctionDeclaration, name: string, type: string): naslTypes.Logic {
   const parameters: babelTypes.Identifier[] = node.params as babelTypes.Identifier[];
   const statements: babelTypes.Statement[] = node.body.body;
 
   const curLogic: any = new naslTypes.Logic({ name: name ?? node.id.name });
-  parameters.forEach((item: babelTypes.Identifier) => {
-    const param = transformParam(item);
-    if (param && param.name !== 'event' && !curLogic.params.find((_: any) => _.name === param.name)) curLogic.addParam(param);
-  });
+  if (type !== 'event_logic') {
+    parameters.forEach((item: babelTypes.Identifier) => {
+      const param = transformParam(item);
+      if (param && param.name !== 'event' && !curLogic.params.find((_: any) => _.name === param.name)) curLogic.addParam(param);
+    });
+  }
   statements.forEach((item) => {
     if (item.type === 'ReturnStatement' && item?.argument) {
-      if (!curLogic.returns.length) {
-        curLogic.returns.push(new naslTypes.Return({
-          name: 'result',
-        }));
+      if (type === 'view_logic') {
+        if (item.argument?.type === 'Identifier') {
+          if (!curLogic.returns.length) {
+            const curVariable = curLogic?.variables?.find((it: any) => it.name === (item?.argument as any)?.name);
+            if (curVariable) {
+              curLogic.variables = curLogic?.variables?.filter((it: any) => it.name !== (item?.argument as any)?.name);
+              curLogic.addReturn(curVariable as any);
+            }
+          }
+        } else {
+          if (!curLogic.returns.length) {
+            curLogic.returns.push(new naslTypes.Return({
+              name: 'result',
+            }));
+          }
+          const logicItem = new naslTypes.Assignment({
+            left: new naslTypes.Identifier({
+              name: curLogic.returns[0].name,
+            }),
+            right: transformNode2Expression(item.argument, 'logic')
+          });
+          curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+        }
+      } else {
+        if (item.argument?.type !== 'Identifier') {
+          curLogic.addVariable('tempVar');
+          const logicItem = new naslTypes.Assignment({
+            left: new naslTypes.Identifier({
+              name: 'tempVar',
+            }),
+            right: transformNode2Expression(item.argument, 'logic')
+          });
+          curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+        }
       }
-      const logicItem = new naslTypes.Assignment({
-        left: new naslTypes.Identifier({
-          name: curLogic.returns[0].name,
-        }),
-        right: transformNode2Expression(item.argument, 'logic')
-      });
-      curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+
     } else {
       let logicItem = transformNode2Expression(item, 'logic');
       if (logicItem) {
@@ -1080,24 +1106,24 @@ function transformNode2ViewElement(node: babelTypes.NewExpression, componentName
       name,
     });
     viewNode.properties.forEach((prop: any, propIndex: number) => {
-      if (prop.value.type === 'ArrayExpression' && ['FunctionExpression', 'ArrowFunctionExpression'].includes(prop.value.elements[0].type)) {
+      if (prop?.value?.type === 'ArrayExpression' && ['FunctionExpression', 'ArrowFunctionExpression'].includes(prop?.value?.elements?.[0]?.type)) {
         // 事件逻辑
         const eventName = prop?.key?.name?.replace(/^on/, '')?.toLowerCase();
         const bindEvent = new naslTypes.BindEvent({ name: eventName });
         prop.value.elements.forEach((element: any) => {
           const logicName = bindEvent.getLogicUniqueName();
-          const curLogic: any = transformNode2Logic(element, logicName);
+          const curLogic: any = transformNode2Logic(element, logicName, 'event_logic');
           bindEvent.addLogic(curLogic);
         });
         newViewElement.addBindEvent(bindEvent);
-      } else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop.value.type) && /^on/.test(prop.key.name)) {
+      } else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop?.value?.type) && /^on/.test(prop.key.name)) {
         // 事件逻辑
         const eventName = prop?.key?.name?.replace(/^on/, '')?.toLowerCase();
         const bindEvent = new naslTypes.BindEvent({ name: eventName });
         const logicName = bindEvent.getLogicUniqueName();
-        bindEvent.addLogic(transformNode2Logic(prop.value, logicName));
+        bindEvent.addLogic(transformNode2Logic(prop.value, logicName, 'event_logic'));
         newViewElement.addBindEvent(bindEvent);
-      } else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop.value.type) && ['ArrayExpression'].includes(prop.value.body?.type)) {
+      } else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop?.value?.type) && ['ArrayExpression'].includes(prop.value.body?.type)) {
         // 子组件
         const slotTarget = prop.key.name.replace(/^slot/, '').toLowerCase();
         if (slotTarget === 'default') {
@@ -1174,7 +1200,7 @@ function transformNode2ViewConstruct(node: babelTypes.Node): naslTypes.ViewEleme
   // 页面逻辑
   if (node.type === 'FunctionDeclaration') {
     const logicName = node.id.name.replace(/^viewLogic_/, '');
-    return transformNode2Logic(node, logicName);
+    return transformNode2Logic(node, logicName, 'view_logic');
   }
 
   if (node.type === 'ExpressionStatement') {
@@ -1209,10 +1235,17 @@ function transformNode2ViewConstruct(node: babelTypes.Node): naslTypes.ViewEleme
       } else {
         properties?.[3].value.elements.forEach((element: any) => {
           let newNode = {} as any;
+          const propertiesMap = ['BindDirective', 'BindStyle', 'BindAttribute'];
           if (properties?.[2].value.value === 'ViewElement') {
             newNode = transformNode2ViewConstruct(element);
-          } else if (properties?.[2].value.value === 'BindAttribute') {
+          } else if (propertiesMap.includes(properties?.[2]?.value?.value)) {
             newNode = transformNode2Attribute({ key: element.left, value: element.right });
+          } else if (properties?.[2]?.value?.value === 'BindEvent') {
+            const eventName = element?.left?.name?.replace(/^on/, '')?.toLowerCase();
+            const bindEvent = new naslTypes.BindEvent({ name: eventName });
+            const logicName = bindEvent.getLogicUniqueName();
+            bindEvent.addLogic(transformNode2Logic(element?.right?.elements[0], logicName, 'event_logic'));
+            newNode = bindEvent;
           }
           const newNodeBackup = cloneDeep(newNode);
           (newNode as any).aiParams = {
@@ -1263,6 +1296,8 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: ParseRe
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'ArrayExpression') {
       viewItem?.forEach((element: any) => {
         if (element.aiParams) json.push(element.aiParams);
+        if (element?.concept === 'ViewElement')
+          view.addViewElement(element);
       });
     }
     if (viewItem?.concept === 'Variable') {

package/src/natural/transformTSCode.ts

@@ -429,7 +429,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         });
       }
       if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
-        const entityName = callee[0].name.replace(/Entity$/, '');
+        const entityName = callee[0].name.replace(/Entity/, '');
         return new naslTypes.CallLogic({
           calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
           calleeName: (callee[1] as babelTypes.Identifier).name,
@@ -625,7 +625,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       } else if (/^app.dataSources|app.logics/.test(calleeName)) {
         if (calleeName?.includes('.entities.')) {
           const calleeNamespace = generate((node?.callee as any)?.object?.object)?.code;
-          const entityName = (node?.callee as any)?.object?.property?.name?.replace(/Entity$/, '');
+          const entityName = (node?.callee as any)?.object?.property?.name?.replace(/Entity/, '');
           return new naslTypes.CallLogic({
             calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
             calleeName: (node?.callee as any)?.property?.name,
@@ -677,7 +677,10 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           }))).flat() as naslTypes.Argument[],
         });
       } else if (/connector./.test(calleeName)) {
-        const flatCalleeKey = generate(node?.callee as any)?.code;
+        let flatCalleeKey = generate(node?.callee as any)?.code;
+        if (flatCalleeKey?.startsWith('connector.')) {
+          flatCalleeKey = flatCalleeKey?.replace('connector.', '');
+        }
         const [, calleeConnectionName, calleeNamespace, calleeFunName] = flatCalleeKey?.match(/^(\w+)\.([\w.]+)\.(\w+)$/);
         return new naslTypes.CallConnector({
           calleeConnectionName,
@@ -972,20 +975,27 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       }
     } else if (node.type === 'ReturnStatement') {
       if (node.argument) {
-        if (type === 'expression') {
-          return transformLogicNode(node.argument);
-        }
-        if (!logic.returns.length) {
-          logic.returns.push(new naslTypes.Return({
-            name: 'result',
-          }));
+        if (node.argument?.type === 'Identifier') {
+          if (!logic.returns.length) {
+            const curVariable = logic?.variables?.find((item) => item.name === (node?.argument as any)?.name);
+            if (curVariable) {
+              logic.variables = logic?.variables?.filter((item) => item.name !== (node?.argument as any)?.name);
+              logic.addReturn(curVariable as any);
+            }
+          }
+        } else {
+          if (!logic.returns.length) {
+            logic.returns.push(new naslTypes.Return({
+              name: 'result',
+            }));
+          }
+          return new naslTypes.Assignment({
+            left: new naslTypes.Identifier({
+              name: logic.returns[0].name,
+            }),
+            right: transformLogicNode(node.argument),
+          });
         }
-        return new naslTypes.Assignment({
-          left: new naslTypes.Identifier({
-            name: logic.returns[0].name,
-          }),
-          right: transformLogicNode(node.argument),
-        });
       }
       if ((node as any)?.ends) {
         return new naslTypes.End();

package/src/server/naslServer.ts

@@ -416,6 +416,7 @@ class NaslServer {
 
     // 处理一堆api.ts的类型
     const convertTsCode = (code: string) => {
+      code = code || '';
       code = code.replace(/nasl.core.Integer/g, 'nasl.core.Long')
       // 匹配union类型的正则
       const unionReg = /\s*['"].*['"](\s*\|\s*['"].*['"])+/g;

package/src/translator/utils.ts

@@ -258,7 +258,7 @@ export function transfromUnionTypeAnnotation(expTypeAnnotation: TypeAnnotation,
 export function createDescriptionComment<T extends BaseNode>(state: TranslatorState, node: T, properties: Array<keyof T>) {
   const content = properties.map((prop) => node[prop]).filter((value) => !!value).join(' ');
 
-  return content.trim() ? `/** ${content} */\n${indent(state.tabSize)}` : '';
+  return content.trim() ? `/* ${content} */\n${indent(state.tabSize)}` : '';
 }
 
 export function createDecoratorCode<T extends BaseNode>(state: TranslatorState, node: T, properties: Array<keyof T>, options?: {