@lcap/nasl 3.8.2-alpha.1 → 3.8.2-alpha.3

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;
@@ -176,13 +177,13 @@ ${item.tsDeclaration}`).join('\n')}`);
 };
 
 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 };
 }
@@ -616,7 +617,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') {
@@ -641,6 +642,7 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
       createCompilerState('', {
         focusedNodePath,
         needNamespace: true,
+        typeMap,
       }),
       function (state) {
         let code = '';
@@ -649,6 +651,7 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
         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) => {
@@ -663,17 +666,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(
@@ -710,13 +732,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') {
@@ -735,9 +758,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) => {
@@ -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,51 @@ 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;
+      typeMap[ret.nodePath] = typeAnnotation.toNaturalTS(state);
+    }
+  });
+  const params = activeDesignerNode?.params.concat(activeDesignerNode?.virtualParams || []);
+  if (params?.length) {
+    let code = '';
+    params?.forEach((param: any, index: number) => {
+      if (param.name === 'event') code += 'event';
+      else code += param.toNaturalTS(state);
+      if (index !== params.length - 1) 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 };
+};

package/src/server/getMemberIdentifier.ts

@@ -15,9 +15,9 @@ import {
   types,
   ViewElement,
   PAGE_COMPONENT_INCLUDE_TAG_MAP,
-  ComponentCompletionPropertyMap,
   configurationEnums,
   processV2Enums,
+  config,
 } from '..';
 import { formatVariableData, formatFrontEndVariables, formatConfigProperties, formatBackendVariables } from './formatTsUtils';
 
@@ -422,8 +422,8 @@ export function getConfigsIdentifier(node: BaseNode): CompletionProperty[] {
 }
 function flatElements(elements: ViewElement[], componentList: CompletionProperty[], nodeParentElement: string, currentAttriBute: string, parentNodeNames: string[]) {
   elements?.forEach((item) => {
-    // 根据ComponentCompletionPropertyMap添加
-    if (ComponentCompletionPropertyMap?.[item.tag]) {
+    // 根据readablePropsMap添加
+    if (config?.allNodesAPI[item.tag] && config?.allNodesAPI[item.tag].readablePropsMap) {
       // 是否当前组件
       const isCurrent = item.name === nodeParentElement;
       const stashItem: any = {
@@ -436,9 +436,9 @@ function flatElements(elements: ViewElement[], componentList: CompletionProperty
         children: [],
       }
 
-      for (const key in ComponentCompletionPropertyMap[item.tag]) {
-        if (Object.prototype.hasOwnProperty.call(ComponentCompletionPropertyMap[item.tag], key)) {
-          const property = ComponentCompletionPropertyMap[item.tag][key];
+      for (const key in config?.allNodesAPI[item.tag].readablePropsMap) {
+        if (Object.prototype.hasOwnProperty.call(config?.allNodesAPI[item.tag].readablePropsMap, key)) {
+          const property = config?.allNodesAPI[item.tag].readablePropsMap[key];
 
           // 如果是当前组件，过滤掉当前属性
           if (!isCurrent || currentAttriBute !== property.prop) {
@@ -454,7 +454,7 @@ function flatElements(elements: ViewElement[], componentList: CompletionProperty
               })
             })
 
-            completionProperty.name = `${key}（${property.label}）`;
+            completionProperty.name = `${key}（${property.title}）`;
             completionProperty.icon = property.icon || 'attr'
             stashItem.children.push(completionProperty)
           }
@@ -511,21 +511,21 @@ function getCurrentElement(item: any): ViewElement | undefined {
   if (!item?.parentNode) return undefined
   if (item.parentNode?.concept === 'ViewElement') {
     return item.parentNode
-  } else if (item.parentNode?.concept === 'View') {
+  } if (item.parentNode?.concept === 'View') {
     return undefined
-  } else {
-    return getCurrentElement(item.parentNode)
   }
+    return getCurrentElement(item.parentNode)
+
 }
 
 function getCurrentAttriBute(item: any): BindAttribute | undefined {
   if (item.concept === 'BindAttribute') {
     return item
-  } else {
+  }
     if (item?.parentNode && item.parentNode?.concept !== 'View') {
       return getCurrentAttriBute(item.parentNode)
-    } else {
-      return undefined
     }
-  }
+      return undefined
+
+
 }

package/src/server/naslServer.ts

@@ -653,7 +653,7 @@ class NaslServer {
     app.naslServer = this;
     const self = this;
     this.performance = performance;
-    const results = await utils.timeSlicingWithGenerator(getAllTsFiles());
+    const results = await utils.runGeneratorAsync(getAllTsFiles());
     const files = results.map((result) => ({
       file: result.filePath,
       fileContent: result.code,

package/src/translator/types.ts

@@ -96,6 +96,8 @@ export interface TranslatorState {
   isVariableHost?: boolean;
   /** DataSource 声明 */
   isDataSource?: boolean;
+  /** 推导类型集合，toNaturalTS 使用 */
+  typeMap?: any;
 }
 
 export type SourceMapItem = Range;

package/test/concepts/member-expression/__snapshots__/toJS.spec.ts.snap

@@ -6,7 +6,7 @@ exports[`member-expression:toJS app.enums.UserStatusEnum 1`] = `
 `;
 
 exports[`member-expression:toJS elements.table-view.data 1`] = `
-"this.__tableView_dataSource;
+"this.__tableView_data;
 "
 `;
 

package/test/concepts/member-expression/__snapshots__/toVue.spec.ts.snap

@@ -6,7 +6,7 @@ exports[`member-expression:toVue app.enums.UserStatusEnum 1`] = `
 `;
 
 exports[`member-expression:toVue elements.table-view.data 1`] = `
-"<template>__tableView_dataSource</template>
+"<template>__tableView_data</template>
 "
 `;
 

package/sandbox-natural/stdlib/nasl.core.ts

@@ -1,47 +0,0 @@
-type Any = any;
-type Long = number;
-type Integer = number;
-type Decimal = number;
-// type Boolean = boolean;
-// type String = string;
-// type Date = globalThis.Date;
-
-class Time {
-  accept: 'Time';
-}
-class DateTime {
-  accept: 'DateTime';
-}
-type List<T> = Array<T>;
-
-interface Entity<T> {
-  get(id: Integer): T; // 只能获取一条 Entity 数据，返回一个 Entity 对象
-  create(entity: T): T;
-  update(entity: T): T;
-  delete(id: Integer): void;
-  createOrUpdate(body: T): T;
-  batchCreate(list: List<T>): List<T>;
-  batchUpdate(list: List<T>): List<T>;
-  batchDelete(list: List<Integer>): void;
-}
-declare function EntityRelation(property: any): any;
-declare const createEntity: <T>() => Entity<T>;
-
-declare function ForEach<T>(list: List<T>, start: Integer, end: Integer, fn: (item: T, index: Integer) => void): void;
-
-declare function plus(left: Decimal, right: Decimal): Decimal;
-declare function minus(left: Decimal, right: Decimal): Decimal;
-declare function multiply(left: Decimal, right: Decimal): Decimal;
-declare function divide(left: Decimal, right: Decimal): Decimal;
-declare function remainder(left: Decimal, right: Decimal): Decimal;
-
-declare namespace nasl.auth {
-  /* 检查当前用户是否有当前资源的权限 */
-  export function hasAuth(authPath: String): Boolean;
-  /* 退出当前登录状态 */
-  export function logout(): Promise<void>;
-  /* 对字符串 实现aes解密，返回解密后的字符串 */
-  export function encryptByAES(authPath: String): String;
-  /* 对字符串 实现aes加密，返回加密后的字符串 */
-  export function decryptByAES(authPath: String): String;
-}

package/sandbox-natural/stdlib/nasl.oql.ts

@@ -1,14 +0,0 @@
-declare namespace nasl.oql {
-  /**
-   * 数据查询：当前为服务端逻辑时可使用此方法
-   * @param sql 数据查询需要的 SQL
-   * @returns 返回类型中的 T 为 sql 根据 SQL 中 select 的字段推导
-   *
-   * 所有变量格式为：${variable}，不能用''包裹，不能用函数处理。
-   * 优先使用数据库的查询和数据操纵能力，例如 JOIN、SUM、GROUP_BY 等
-   * @example `SELECT * FROM Student WHERE id = ${id}`
-   * @example `SELECT OrderProduct.*, Product.price as price FROM OrderProduct JOIN Product WHERE orderId = ${id}`
-   * @example `SELECT SUM(OrderProduct.amount * Product.price) as total FROM OrderProduct JOIN Product WHERE orderId = ${orderId}`
-   */
-  export function query<T>(sql: string): List<T>;
-}

package/sandbox-natural/stdlib/nasl.ui.ts

@@ -1,63 +0,0 @@
-declare namespace nasl.ui {
-  export interface MouseEvent { }
-
-  export interface ValidateResult { valid: Boolean; }
-
-  export class Button {
-    constructor(options?: {
-      color?: 'default' | 'primary',
-      text?: String,
-      onClick?: () => any,
-    });
-  }
-
-  export class Form {
-    constructor(options?: {});
-
-    validate(): ValidateResult;
-  }
-
-  export class Modal {
-    constructor(options?: {});
-
-    open(): void;
-    close(): void;
-  }
-
-  export class TableView {
-    constructor(options?: {});
-
-    reload(): void;
-  }
-
-  export class Select {
-    constructor(options?: {});
-
-    reload(): void;
-  }
-
-  export class InfoList {
-    constructor(options?: {});
-  }
-
-  export class Collapse {
-    constructor(options?: {});
-  }
-
-  export class Input {
-    constructor(options?: {});
-  }
-
-  export class NumberInput {
-    constructor(options?: {});
-  }
-
-  export function showMessage(text: Any): void;
-
-  /**
-   * 跳转到指定页面
-   * @example nasl.ui.destination('pageType.some_view.sub1_view', param1, param2);
-   * pageType 为 namespace，如 pc 或者 m，必填
-   */
-  export function destination(path: String, ...args: Any[]): void;
-}