@lcap/nasl 3.8.2-beta.8 → 3.8.3-beta.1

package/src/natural/getContext/index.ts

@@ -1,3 +1,4 @@
+import * as utils from '../../utils';
 import { App, View, Logic, BaseNode, Frontend, Namespace, Module, TypeAnnotation, Structure, Connection, Connector } from '../../concepts';
 import { shiftState, createCompilerState, TranslatorState, indent } from '../../translator';
 import { getPreDeclaration, getUILib, handleMaterial, getExtensionsMaterial } from './getUILib';
@@ -86,7 +87,7 @@ export function getLogicWithStructuresCode(logic: Logic, type: string, desc: { d
 
   newRelationStructures?.forEach((reference: { typeNamespace: string; typeName: string; }) => {
     const { typeName } = reference || {};
-    const state = createCompilerState();
+    const state = createCompilerState('', { descriptionComment: true });
     const tabSize = namespace ? shiftState(state, code, { tabSize: 1 }) : undefined;
     structures?.filter((structure: any) => structure?.name === typeName)
       ?.forEach((structure: any) => {
@@ -96,15 +97,15 @@ export function getLogicWithStructuresCode(logic: Logic, type: string, desc: { d
   if (namespace && newRelationStructures?.length) {
     code += `}\n`;
   }
-  const { description, codeStr } = desc || {};
-  if (description) code += `// ${description}\n`;
+  const { codeStr } = desc || {};
+  // if (description) code += `// ${description}\n`;
   if (codeStr) code += `${codeStr}\n`;
   code = wrapTSBlock(code);
   return code;
 }
 
 export function getNaslCore(logicType: string) {
-  let naslCore = `${getNASLStdlibMap('nasl.core.ts')}\n`;
+  let naslCore = `${getNASLStdlibMap('nasl.core.d.ts')}\n`;
   if (logicType === 'global_logic')
     naslCore += `// 分页组件函数，用于分页
 declare function PAGINATE<T>(list: List<T>, page: Integer, size: Integer): { list: List<T>, total: Integer; };
@@ -114,7 +115,7 @@ declare function PAGINATE<T>(list: List<T>, page: Integer, size: Integer): { lis
 }
 
 export function getNaslUtil() {
-  const naslUtil = `${getNASLStdlibMap('nasl.util.ts')}\n`;
+  const naslUtil = `${getNASLStdlibMap('nasl.util.d.ts')}\n`;
   const code = wrapTSBlock(naslUtil);
   return { code, naslUtil };
 }
@@ -125,7 +126,7 @@ export const getNaslUI = (
   material:
     {
       basicMaterials: 'pc' | 'h5' | { json: any; tsDeclaration: string; };
-      extensionMaterials: {
+      extensionMaterials: 'pc' | 'h5' | {
         name: string;
         title: string;
         description: string;
@@ -170,19 +171,20 @@ export const getNaslUICode = (naslUI: any, codeType: 'detail' | 'short', require
 */
 ${item.tsDeclaration}`).join('\n')}`);
   } else {
+    code += wrapTSBlock(preDeclaration);
     code += uiLib.map((item: any, index: number) => `[3-${index}] ${item.name} | ${item.title} | ${item.description}`).join('\n');
   }
   return code;
 };
 
 export const getNaslUIOld = () => {
-  const naslUI = `${getNASLStdlibMap('nasl.ui.ts')}\n`;
+  const naslUI = `${getNASLStdlibMap('nasl.ui.d.ts')}\n`;
   const code = wrapTSBlock(naslUI);
   return { code, naslUI };
 };
 
 export function getNaslOQL() {
-  const naslOql = `${getNASLStdlibMap('nasl.oql.ts')}\n`;
+  const naslOql = `${getNASLStdlibMap('nasl.oql.d.ts')}\n`;
   const code = wrapTSBlock(naslOql);
   return { code, naslOql };
 }
@@ -215,7 +217,7 @@ export function getEntities(app: App, state: TranslatorState) {
     const data = [] as Snippet[];
     const namespace = `app.dataSources.${dataSource?.name}.entities`;
     dataSource.entities
-      .filter((entity) => !entity.name.startsWith('LCAP') || entity.name === 'LCAPUser')
+      // .filter((entity) => !entity.name.startsWith('LCAP') || entity.name === 'LCAPUser')
       .forEach((entity) => {
         const entityName = `app.dataSources.${dataSource?.name}.entities.${entity?.name}`;
         const tempCode = `${entity?.toNaturalTS({ ...state, needNamespace: true }, entityName)}`;
@@ -231,7 +233,7 @@ export const getEntitiesCode = (entities: any) => {
   entities?.forEach((entity: any) => {
     code += `declare namespace ${entity?.namespace} {\n`;
     entity?.data?.forEach((item: any) => {
-      code += item?.description ? `/* ${item.description} */ \n` : '';
+      // code += item?.description ? `/* ${item.description} */ \n` : '';
       code += `${item.code}\n`;
     });
     code += `}\n`;
@@ -244,7 +246,7 @@ export function getStructures(app: App, state: TranslatorState) {
   const data = [] as Snippet[];
   const namespace = `app.structures`;
   app.structures
-    .filter((entity) => !entity.name.startsWith('LCAP'))
+    // .filter((entity) => !entity.name.startsWith('LCAP'))
     .forEach((structure) => {
       const tempCode = `${structure?.toNaturalTS({ ...state, needNamespace: true })}`;
       data.push({ description: structure?.description || structure?.name, code: tempCode });
@@ -256,7 +258,7 @@ export const getStructuresCode = (structures: any) => {
   let code = '';
   code += `declare namespace ${structures?.namespace} {\n`;
   structures?.data?.forEach((item: any) => {
-    code += item?.description ? `/* ${item.description} */ \n` : '';
+    // code += item?.description ? `/* ${item.description} */ \n` : '';
     code += `${item.code}\n`;
   });
   code += `}\n`;
@@ -265,14 +267,14 @@ export const getStructuresCode = (structures: any) => {
 };
 
 
-export function getLogics(app: App, currentNode: BaseNode) {
+export function getLogics(app: App, currentNode: BaseNode, state: TranslatorState) {
   const data = [] as Snippet[];
   const namespace = `app.logics`;
   app?.logics
     ?.filter((logic) => logic !== currentNode && !logic.name.startsWith('LCAP'))
     ?.forEach((logic) => {
       const rename = logic?.calleewholeKey;
-      const tempCode = `${logic?.toNaturalTS({ needNamespace: true, rename, declaration: true })}`;
+      const tempCode = `${logic?.toNaturalTS({ ...state, needNamespace: true, rename, declaration: true })}`;
       const description = logic?.description || '';
 
       data.push({ description, code: tempCode });
@@ -287,7 +289,8 @@ export const getLogicsCode = (appLogics: any, codeType: 'detail' | 'short', requ
     const logicIndex = `6-${index}`;
     if (requiredIndexes?.length && !requiredIndexes?.includes(logicIndex)) return;
     const tempCode = codeType === 'short' ? item.code.replace(`${appLogics.namespace}.`, '') : item.code;
-    code += `[${logicIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+    code += `[${logicIndex}] \`${tempCode}\`\n`;
+    // code += `[${logicIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
   });
   return code;
 };
@@ -338,8 +341,8 @@ export const getModuleInterfacesCode = (interfaceDependencies: any, codeType: 'd
       if (requiredIndexes?.length && !requiredIndexes?.includes(interfaceIndex)) return;
       if (codeType === 'short') {
         const tempCode = item.code.replace(`${interfaceDependency?.logics.namespace}.`, '');
-        // code += `[${interfaceIndex}] \`${tempCode}\`\n`;
-        code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+        code += `[${interfaceIndex}] \`${tempCode}\`\n`;
+        // code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
       } else {
         code += item.codeWithDetail;
       }
@@ -542,13 +545,37 @@ export const getDependenciesCode = (dependencies: any, codeType: 'detail' | 'sho
 
 export function getFrontendVariables(frontend: Frontend, state: TranslatorState) {
   let code = '';
+  const data = [] as Snippet[];
+  const namespace = frontend?.variables?.[0]?.getNamespace() || '';
   frontend?.variables?.forEach((variable) => {
-    const tempCode = `let ${variable?.toNaturalTS(shiftState(state, code, { inline: true }))};\n`;
+    const tempCode = `let ${variable?.toNaturalTS(shiftState(state, code, { inline: true, needNamespace: true, }))};\n`;
+    data.push({ description: variable?.description || '', code: tempCode });
+    code += tempCode;
+  });
+  return { namespace, frontendVariables: { namespace, data } };
+}
+
+export function getServerVariables(app: App, state: TranslatorState) {
+  let code = '';
+  const data = [] as Snippet[];
+  const namespace = 'app.backend.variables';
+  app.backend?.variables?.forEach((variable) => {
+    const tempCode = `let ${variable?.toNaturalTS(shiftState(state, code, { inline: true, needNamespace: true, }))};\n`;
+    data.push({ description: variable?.description || '', code: tempCode });
     code += tempCode;
   });
-  return { code: wrapTSBlock(code), frontendVar: code, frontendVariables: code };
+  return { namespace, backendVariables: { namespace, data } };
 }
 
+export const getVariablesCode = (variables: any) => {
+  let code = '';
+  variables?.data?.forEach((item: any) => {
+    code += item.description ? `/* ${item.description} */ \n` : '';
+    code += item.code;
+  });
+  return wrapTSBlock(code);
+};
+
 export function getChildrenViews(view: View, currentNode: BaseNode, convertChildren: boolean, prefix: string) {
   const data = [] as Snippet[];
   if (view?.children?.length > 0) {
@@ -606,7 +633,7 @@ export const getFrontendViewsCode = (views: any) => {
   return wrapTSBlock(code);
 };
 
-export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: string, experimental?: boolean) {
+export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: string, experimental?: boolean, typeMap?: any) {
   let code = '';
   let view: View;
   if (currentNode?.concept === 'View') {
@@ -631,14 +658,16 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
       createCompilerState('', {
         focusedNodePath,
         needNamespace: true,
+        typeMap,
       }),
       function (state) {
         let code = '';
         code += `\n${indent(state.tabSize)}`;
-
+        
         if (experimental) {
           code += this.elements[0].toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
         } else {
+          code += `${indent(state.tabSize + 1)}`;
           code += `const $refs = {\n`;
           // 生成所有的name和类型定义
           this.elements.forEach((element) => {
@@ -653,17 +682,36 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
         // 逻辑
         if (currentNode?.concept === 'Logic') {
           code += '\n';
+          this.bindEvents.forEach((bindEvent) => {
+            bindEvent.logics.forEach((logic) => {
+              if (logic === currentNode) return;
+              const logicCode = logic.toNaturalTS(
+                shiftState(state, code, {
+                  tabSize: state.tabSize + 1,
+                  // declaration: true,
+                  autoPrefixName: true,
+                })
+              );
+              code += logicCode.replace('function ', 'private function ');
+              code += '\n';
+            });
+            if (bindEvent.logics.length) code += '\n';
+          });
+
           this.logics.forEach((logic) => {
             if (logic === currentNode) return;
-            code += logic.toNaturalTS(
+            const logicCode = logic.toNaturalTS(
               shiftState(state, code, {
                 tabSize: state.tabSize + 1,
                 declaration: true,
                 autoPrefixName: true,
               })
             );
+            code += logicCode.replace('declare function', 'function');
             code += '\n';
           });
+          if (this.logics.length) code += '\n';
+
           // 包含了事件逻辑的处理
           code += `${indent(state.tabSize + 1)}/* 当前逻辑 */\n`;
           code += (currentNode as Logic).toNaturalTS(
@@ -700,13 +748,14 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
         needNamespace: true,
         declaration: logic !== currentNode,
         autoPrefixName: true,
+        typeMap
       })
     );
   }
   return { code: wrapTSBlock(code), currentLogic: code };
 }
 
-export function getCurrentNodeContextForUI(currentNode: BaseNode) {
+export function getCurrentNodeContextForUI(currentNode: BaseNode, typeMap?: any) {
   let code = '';
   let view: View;
   if (currentNode?.concept === 'View') {
@@ -725,9 +774,62 @@ export function getCurrentNodeContextForUI(currentNode: BaseNode) {
     code += view?.toNaturalTS(
       createCompilerState('', {
         needNamespace: true,
+        typeMap,
       })
     );
   }
 
   return { code: wrapTSBlock(code), currentLogic: code };
 }
+
+
+const calcComponent = (activeDesignerNode: any) => {
+  const view = activeDesignerNode?.concept === 'View' ? activeDesignerNode?.elements?.[0] : (activeDesignerNode.getAncestor('View') as any)?.elements?.[0];
+  const componentSet = new Set();
+  if (view) {
+    utils.traverse(({ node }: { node: any; }) => {
+      if (node.concept === 'ViewElement') {
+        const name = utils.kebab2Camel(node.tag);
+        componentSet.add(name);
+      }
+    }, { node: view });
+  }
+  return componentSet;
+};
+
+
+const extractUFormClass = (tsDeclaration: string) => {
+  const regex = /class\s+(\w+)(?:<[^>]+>)?\s+extends\s+(\w+)\s*\{(.*?)\}/s;
+  const match = tsDeclaration.match(regex);
+  let code = '';
+  if (match) {
+    const [, className, baseClassName, classBody] = match;
+    const methodRegex = /\s*(\w+)\(([^)]*)\):\s*(\w+)/g;
+    code = `export class ${className} extends ${baseClassName} {`;
+    const newClassBody = classBody.replace(/nasl\.core\./g, "")
+      .replace(/Integer/g, "Long");
+    const body = newClassBody.replace(methodRegex, (method) => {
+      code += `${method};`;
+      return '';
+    });
+    code += `\n}\n`;
+    if (body === classBody) {
+      return '';
+    }
+  }
+  return code;
+};
+
+export function getCurrentComponentDeclaration(activeDesignerNode: any, components: any) {
+  let code = '';
+  const componentSet = calcComponent(activeDesignerNode);
+  if (!componentSet.size) return { componentDeclaration: '' };
+  // 遍历map，找到对应的组件
+  const result = components.filter((component: any) => componentSet.has(component.name));
+  result.forEach((component: any) => {
+    const newTsDeclaration = component.tsDeclaration;
+    const uFormClass = extractUFormClass(newTsDeclaration);
+    code += uFormClass;
+  });
+  return { componentDeclaration: code };
+}

package/src/natural/getContext/naslStdlibMap.ts

@@ -4,20 +4,20 @@ export const getNASLStdlibMap = (key?: string) => {
   if (globalThis.process) { // For TS build
     const fs = require('fs');
     naslStdlibMap = {
-      'nasl.core.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.core.ts'), 'utf8'),
-      'nasl.util.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.util.ts'), 'utf8'),
-      'nasl.ui.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.ui.ts'), 'utf8'),
-      'nasl.oql.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.oql.ts'), 'utf8'),
+      'nasl.core.d.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.core.d.ts'), 'utf8'),
+      'nasl.util.d.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.util.d.ts'), 'utf8'),
+      'nasl.ui.d.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.ui.d.ts'), 'utf8'),
+      'nasl.oql.d.ts': fs.readFileSync(require.resolve('../../../sandbox-natural/stdlib/nasl.oql.d.ts'), 'utf8'),
     };
   }
   /// #endif
   /// #if process.env.BUILD_TARGET !== 'node'
   if (globalThis.window) { // For TS build
     naslStdlibMap = {
-      'nasl.core.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.core.ts').default,
-      'nasl.util.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.util.ts').default,
-      'nasl.ui.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.ui.ts').default,
-      'nasl.oql.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.oql.ts').default
+      'nasl.core.d.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.core.d.ts').default,
+      'nasl.util.d.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.util.d.ts').default,
+      'nasl.ui.d.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.ui.d.ts').default,
+      'nasl.oql.d.ts': require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.oql.d.ts').default
     };
   }
   /// #endif

package/src/natural/tools.ts

@@ -1,5 +1,6 @@
 import { App, BaseNode } from "src/concepts";
 import * as utils from '../utils';
+import { createCompilerState } from '../translator';
 
 // 获取当前逻辑的类型
 export const getLogicType = (activeLogic: any) => {
@@ -32,7 +33,7 @@ export const getUsedModule = (json: BaseNode) => {
         useModule.push(item);
       }
     }
-    if (node.concept === 'ViewElement') {
+    if (node.concept === 'ViewElement' && node?.tag) {
       const symbol = utils.kebab2Camel(node.tag);
       const item = {
         symbol,
@@ -80,7 +81,7 @@ export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material:
       // 如果 连接器 不存在，则需要导入并初始化连接
       if (!connectorNode) {
         item.operator = 'importAndInit';
-        const curDep = material?.connectors?.find((node: any) => node.name === item.symbol)
+        const curDep = material?.connectors?.find((node: any) => node.name === item.symbol);
         item.version = curDep?.version;
         item.provider = curDep?.provider || '资产中心';
         needImportModule.needImportConnector = true;
@@ -136,3 +137,107 @@ export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material:
   return needImportModule;
 };
 
+
+
+/**
+ * 找到当前节点所使用的当前逻辑、服务端逻辑、组件相关的推导类型
+ * @param app: 当前应用
+ * @returns 推导类型集合
+ */
+export const deduceType = async (app: App, activeDesignerNode: any) => {
+  const typeMap = {} as any;
+  const { logics } = app;
+  const state = createCompilerState('', { descriptionComment: true, needNamespace: true });
+
+  logics.forEach((logic: any) => {
+    if (logic?.returns?.length && !logic.name.startsWith('LCAP')) {
+      const ret = logic.returns[0];
+      const typeAnnotation = ret?.typeAnnotation || ret?.__TypeAnnotation;
+      if (typeAnnotation)
+        typeMap[ret.nodePath] = typeAnnotation.toNaturalTS(state);
+    }
+  });
+
+  const params = activeDesignerNode?.params.concat(activeDesignerNode?.virtualParams || []);
+  if (params?.length) {
+    let code = '';
+    params?.forEach((param: any, index: number) => {
+      let curCode = '';
+      if (param.name === 'event') curCode += '';
+      else curCode += param.toNaturalTS(state);
+      if (curCode && index !== params.length - 1) curCode += ', ';
+      code += curCode;
+    });
+    if (code)
+      typeMap[activeDesignerNode.nodePath] = code;
+  }
+  const view = activeDesignerNode?.concept === 'View' ? activeDesignerNode?.elements?.[0] : (activeDesignerNode.getAncestor('View') as any)?.elements?.[0];
+  if (view) {
+    const dataSchemaMap = {} as any;
+    utils.traverse(({ node }: { node: any; }) => {
+      if (node.concept === 'ViewElement') {
+        const dataSchema = node.bindAttrs.find((_: any) => _.name === 'dataSchema');
+        if (dataSchema) dataSchemaMap[dataSchema.nodePath] = node;
+      }
+    }, { node: view });
+    await Promise.all(Object.entries(dataSchemaMap).map(async ([nodePath, node]) => {
+      const res = await app.naslServer.getDataSchemaStructureOrTypeAnnotation(node as any);
+      if (res) {
+        const dataSchemaTs = res.toNaturalTS(state);
+        typeMap[nodePath] = dataSchemaTs;
+      }
+    }));
+  }
+  return { typeMap };
+};
+
+/**
+ * 组合所有的可推导类型
+ * @param app: 当前应用
+ * @returns 推导类型集合
+ */
+export const deduceTypeAll = async (app: App) => {
+  const typeMap = {} as any;
+  const { logics } = app;
+  const state = createCompilerState('', { descriptionComment: true, needNamespace: true });
+
+  logics.forEach((logic: any) => {
+    if (logic?.returns?.length && !logic.name.startsWith('LCAP')) {
+      const ret = logic.returns[0];
+      const typeAnnotation = ret?.typeAnnotation || ret?.__TypeAnnotation;
+      if (typeAnnotation)
+        typeMap[ret.nodePath] = typeAnnotation.toNaturalTS(state);
+    }
+  });
+  const dataSchemaMap = {} as any;
+  utils.traverse(({ node }: { node: any; }) => {
+    if (node?.concept === 'ViewElement') {
+      const dataSchema = node.bindAttrs.find((_: any) => _.name === 'dataSchema');
+      if (dataSchema) dataSchemaMap[dataSchema.nodePath] = node;
+    }
+    if (node?.concept === 'Logic' && node?.parentNode?.concept === 'BindEvent') {
+      const params = node?.params.concat(node?.virtualParams || []);
+      if (params?.length) {
+        let code = '';
+        params?.forEach((param: any, index: number) => {
+          let curCode = '';
+          if (param.name === 'event') curCode += '';
+          else curCode += param.toNaturalTS(state);
+          if (curCode && index !== params.length - 1) curCode += ', ';
+          code += curCode;
+        });
+        if (code)
+          typeMap[node.nodePath] = code;
+      }
+    }
+  }, { node: app }, { mode: 'onlyArray' });
+  await Promise.all(Object.entries(dataSchemaMap).map(async ([nodePath, node]) => {
+    const res = await app.naslServer.getDataSchemaStructureOrTypeAnnotation(node as any);
+    if (res) {
+      const dataSchemaTs = res.toNaturalTS(state);
+      typeMap[nodePath] = dataSchemaTs;
+    }
+  }));
+
+  return { typeMapAll: typeMap };
+};