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

package/src/concepts/App__.ts

@@ -1,14 +1,13 @@
 import { queryNodeByPath } from '../service/storage/jsoner';
 import { getNaslNodeByNodeCallee, getNodeByNodeCallee } from '../automate/engine/utils';
-import ConfigProperty from './ConfigProperty__';
-import TypeAnnotation from './TypeAnnotation__';
-import View from './View__';
-import AuthInterface from './AuthInterface__';
-import Interface from './Interface__';
+import type ConfigProperty from './ConfigProperty__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type View from './View__';
+import type AuthInterface from './AuthInterface__';
+import type Interface from './Interface__';
+import type Frontend from './Frontend__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
-// import CallLogic from './CallLogic__';
-
 export interface AssetsInfo {
   js: Array<string>;
   css: Array<string>;
@@ -59,7 +58,7 @@ import type Enum from './Enum__';
 import type Logic from './Logic__';
 import type OverriddenLogic from './OverriddenLogic__';
 import type AbstractInterface from './AbstractInterface__';
-import type Frontend from './Frontend__';
+import type FrontendType from './FrontendType__';
 import Backend from './Backend__';
 import type Process from './Process__';
 import type Role from './Role__';
@@ -206,14 +205,14 @@ export class App extends BaseNode {
   interfaces: Array<AbstractInterface> = [];
 
   /**
-   * 前端列表
+   * 端类型列表
    */
   @property({
-    objectRef: 'Frontend',
+    objectRef: 'FrontendType',
     isArray: true,
     defaultValue: [],
   })
-  frontends: Array<Frontend> = [];
+  frontendTypes: Array<FrontendType> = [];
 
   /**
    * 后端
@@ -1471,156 +1470,158 @@ export class App extends BaseNode {
     return utils.unique(name, this.getAbstractInterfaceExistingNames(), undefined, true);
   }
 
-  getFrontendExistingNames(excludedList: Array<Frontend> = []) {
+  getFrontendTypeExistingNames(excludedList: Array<FrontendType> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.frontendTypes as FrontendType[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item?.name);
   }
-  getFrontendUniqueName(name = 'frontend1') {
-    return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
+  getFrontendTypeUniqueName(name = 'frontendType1') {
+    return utils.unique(name, this.getFrontendTypeExistingNames(), undefined, true);
   }
 
   /**
-   * 插入前端
+   * 插入端类型
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  _insertFrontendAt(name: string, index: number): Frontend;
+  _insertFrontendTypeAt(name: string, index: number): FrontendType;
 
   /**
-   * 插入前端
+   * 插入端类型
    * @internal
-   * @param frontendOptions 前端参数
+   * @param frontendTypeOptions 端类型参数
    */
-  _insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+  _insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
 
   /**
-   * 插入前端
+   * 插入端类型
    * @internal
-   * @param frontend 已有的前端实例
+   * @param frontendType 已有的端类型实例
    */
-  _insertFrontendAt(frontend: Frontend, index: number): Frontend;
+  _insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
 
-  _insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
-    const frontendOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'frontends' };
-    const Frontend = getConceptConstructor('Frontend');
-    let frontend: Frontend;
+  _insertFrontendTypeAt(options: string | Partial<FrontendType> | FrontendType, index: number) {
+    const frontendTypeOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'frontendTypes' };
+    const FrontendType = getConceptConstructor('FrontendType');
+    let frontendType: FrontendType;
     if (!options) {
-      frontend = Frontend.from(
+      frontendType = FrontendType.from(
         {
-          ...frontendOptions,
-          name: this.getFrontendUniqueName(),
+          ...frontendTypeOptions,
+          name: this.getFrontendTypeUniqueName(),
         },
         this,
-        'frontends',
+        'frontendTypes',
       );
     } else if (typeof options === 'string') {
-      frontend = Frontend.from(
+      frontendType = FrontendType.from(
         {
-          ...frontendOptions,
+          ...frontendTypeOptions,
           name: options,
         },
         this,
-        'frontends',
+        'frontendTypes',
       );
-    } else if (asserts.isFrontend(options)) {
+    } else if (asserts.isFrontendType(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      frontend = options;
-      Object.assign(frontend, relationOptions);
+      frontendType = options;
+      Object.assign(frontendType, relationOptions);
     } else {
-      frontend = Frontend.from(
+      frontendType = FrontendType.from(
         {
-          ...frontendOptions,
+          ...frontendTypeOptions,
           ...options,
         },
         this,
-        'frontends',
+        'frontendTypes',
       );
     }
-    this.frontends.splice(index, 0, frontend);
-    return frontend;
+    this.frontendTypes.splice(index, 0, frontendType);
+    return frontendType;
   }
 
   /**
-   * 插入前端
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * 插入端类型
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  insertFrontendAt(name: string, index: number): Frontend;
+  insertFrontendTypeAt(name: string, index: number): FrontendType;
 
   /**
-   * 插入前端
-   * @param frontendOptions 前端参数
+   * 插入端类型
+   * @param frontendTypeOptions 端类型参数
    */
-  insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+  insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
 
   /**
-   * 插入前端
-   * @param frontend 已有的前端实例
+   * 插入端类型
+   * @param frontendType 已有的端类型实例
    */
-  insertFrontendAt(frontend: Frontend, index: number): Frontend;
+  insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
 
-  insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
-    const node = this._insertFrontendAt(options as any, index);
+  insertFrontendTypeAt(options: string | Partial<FrontendType> | FrontendType, index: number) {
+    const node = this._insertFrontendTypeAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontends',
+      parentKey: 'frontendTypes',
     });
     return node;
   }
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  _addFrontend(name?: string): Frontend;
+  _addFrontendType(name?: string): FrontendType;
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param frontendOptions 前端参数
+   * @param frontendTypeOptions 端类型参数
    */
-  _addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+  _addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param frontend 已有的前端实例
+   * @param frontendType 已有的端类型实例
    */
-  _addFrontend(frontend: Frontend): Frontend;
+  _addFrontendType(frontendType: FrontendType): FrontendType;
 
-  _addFrontend(options?: string | Partial<Frontend> | Frontend) {
-    const index = this.frontends.length;
-    return this._insertFrontendAt(options as any, index);
+  _addFrontendType(options?: string | Partial<FrontendType> | FrontendType) {
+    const index = this.frontendTypes.length;
+    return this._insertFrontendTypeAt(options as any, index);
   }
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  addFrontend(name?: string): Frontend;
+  addFrontendType(name?: string): FrontendType;
 
   /**
-   * 添加前端
-   * @param frontendOptions 前端参数
+   * 添加端类型
+   * @param frontendTypeOptions 端类型参数
    */
-  addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+  addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
 
   /**
-   * 添加前端
-   * @param frontend 已有的前端实例
+   * 添加端类型
+   * @param frontendType 已有的端类型实例
    */
-  addFrontend(frontend: Frontend): Frontend;
+  addFrontendType(frontendType: FrontendType): FrontendType;
 
-  addFrontend(options?: string | Partial<Frontend> | Frontend) {
-    const node = this._addFrontend(options as any);
-    const index = this.frontends.indexOf(node);
+  addFrontendType(options?: string | Partial<FrontendType> | FrontendType) {
+    const node = this._addFrontendType(options as any);
+    const index = this.frontendTypes.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontends',
+      parentKey: 'frontendTypes',
     });
     return node;
   }
@@ -3238,45 +3239,45 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除前端
-   * @param name 前端名称
+   * 删除端类型
+   * @param name 端类型名称
    */
-  removeFrontend(name: string): void;
+  removeFrontendType(name: string): void;
 
   /**
-   * 删除前端
-   * @param frontend 已有的前端实例
+   * 删除端类型
+   * @param frontendType 已有的端类型实例
    */
-  removeFrontend(frontend: Frontend): void;
+  removeFrontendType(frontendType: FrontendType): void;
 
-  removeFrontend(options: string | Frontend) {
-    let frontend: Frontend;
+  removeFrontendType(options: string | FrontendType) {
+    let frontendType: FrontendType;
     if (typeof options === 'string') {
-      frontend = (this.frontends as Frontend[]).find((item) => item.name === options);
-      if (!frontend) {
-        throw new Error('找不到前端 ' + options);
+      frontendType = (this.frontendTypes as FrontendType[]).find((item) => item.name === options);
+      if (!frontendType) {
+        throw new Error('找不到端类型 ' + options);
       }
     } else {
-      frontend = options;
+      frontendType = options;
     }
-    return frontend.delete();
+    return frontendType.delete();
   }
 
-  __removeFrontend(frontend: Frontend) {
-    const parentKey = frontend.parentKey;
+  __removeFrontendType(frontendType: FrontendType) {
+    const parentKey = frontendType.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: frontend,
+      oldObject: frontendType,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = frontend.__v_raw || frontend;
+      const n = frontendType.__v_raw || frontendType;
       if (Array.isArray((t as any)[parentKey])) {
         // @ts-ignore
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
@@ -3938,6 +3939,17 @@ export class App extends BaseNode {
   composeCache: composeCacheType = {};
 
 
+  /**
+   * 获取组合节点
+   */
+  getCompose(path: string[]) {
+    let compose = this.composeCache;
+    path.forEach((key) => {
+      compose = compose?.[key];
+    });
+    return compose || null;
+  }
+
   /**
    * 获取组合节点
    */
@@ -4169,10 +4181,10 @@ export class App extends BaseNode {
         names: [],
       },
     };
-    const frontends = this.frontends.filter((frontend) => frontend.type === scope);
+    const frontendTypes = this.frontendTypes.filter((frontendType) => frontendType.kind === scope);
     const existingSet = new Set();
-    frontends.forEach((frontend) => {
-      frontend.componentDependencies.forEach((dep) => {
+    frontendTypes.forEach((frontendType) => {
+      frontendType.componentDependencies.forEach((dep) => {
         const { name, version } = dep;
         const jsName = `${prefix}/packages/${name}@${version}/dist-theme/index.js`;
         if (!existingSet.has(jsName)) {
@@ -4279,7 +4291,11 @@ export class App extends BaseNode {
       structureCount: this.structures.length,
       enumCount: this.enums.length,
       logicCount: this.logics.length,
-      viewCount: sum(this.frontends.map((frontend) => countView(frontend.views))),
+      viewCount: sum(
+        this.frontendTypes.map((frontendType) =>
+          sum(frontendType.frontends.map((frontend) => countView(frontend.views))),
+        ),
+      ),
       processCount: this.processes.length,
     };
   }
@@ -4451,35 +4467,19 @@ export class App extends BaseNode {
     return errorList;
   }
 
-  addFrontendForType(options?: string | Partial<Frontend> | Frontend) {
-    let insertIndex = -1;
-    this.frontends.forEach((frontend, index) => {
-      if (frontend.type === (options as any).type) {
-        insertIndex = index;
-      }
-    });
-    if ((options as any).type === 'h5' && insertIndex === -1) {
-      insertIndex = this.frontends.length;
-    }
-    const node = this._insertFrontendAt(options as any, insertIndex + 1);
-    const index = this.frontends.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'frontends',
-    });
-    return node;
-  }
-
   getFrontendExistingTitles(excludedList: Array<Frontend> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
+    return (this.frontendTypes || [])
+      .map((frontendType) => frontendType.frontends?.filter((item) => !excludedSet.has(item)).map((item) => item.title))
+      .flat(2);
   }
 
   getExtensionsCallbackLogics() {
     let resultLogics: string[] = [];
-    this.frontends.forEach((frontend) => {
-      resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
+    this.frontendTypes.forEach((frontendType) => {
+      frontendType?.frontends?.forEach((frontend) => {
+        resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
+      });
     });
     return Array.from(new Set(resultLogics));
   }
@@ -4493,7 +4493,6 @@ export class App extends BaseNode {
   }
 
   genAllCustomComponents() {
-    const { frontends } = this;
     const compMap: {
       pc: Array<any>;
       h5: Array<any>;
@@ -4502,12 +4501,12 @@ export class App extends BaseNode {
       h5: [],
     };
     const existingSet = new Set();
-    frontends.forEach((frontend) => {
-      if (frontend.componentDependencies) {
-        frontend.componentDependencies.forEach((dep) => {
+    this.frontendTypes.forEach((frontendType) => {
+      if (frontendType.componentDependencies) {
+        frontendType.componentDependencies.forEach((dep) => {
           const { name } = dep;
           if (!existingSet.has(name)) {
-            compMap[frontend.type].push(dep);
+            compMap[frontendType.kind].push(dep);
           }
         });
       }

package/src/concepts/BackendVariable__.ts

@@ -321,12 +321,20 @@ export class BackendVariable extends BaseNode {
   toJS(state?: TranslatorState): string {
     const context = this.view ? 'this' : 'Vue.prototype';
     const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
+    let { sortedTypeKey, typeKind, typeName, typeNamespace } = typeAnnotation || {};
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = this.app.findNodeByCompleteName(typeNamespace + '.' + typeName) || {};
+      const typeAn = referenceNode.typeAnnotation || {};
+      sortedTypeKey = `${typeAn.typeNamespace}.${typeAn.typeName}`;
+      typeKind = typeAn.typeKind;
+      typeName = typeAn.typeName;
+    }
     const needGenInitFromSchema =
       typeAnnotation &&
-      (!['primitive', 'union'].includes(typeAnnotation.typeKind) || typeAnnotation.typeName === 'DateTime');
+      (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
     let code = `${this.name} =`;
     if (needGenInitFromSchema) {
-      code += `${context}.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;
+      code += `${context}.$genInitFromSchema('${sortedTypeKey}',`;
     }
 
     if (this.defaultValue?.expression) {

package/src/concepts/BindAttribute__.ts

@@ -1085,10 +1085,14 @@ export class BindAttribute extends BaseNode {
     const self = this;
     const { name, type, value, rules, expression, playground } = self;
     let code = '';
-    if (self?.name === 'data-source' && self?.expression?.concept === 'CallLogic') {
-      code = `() => {`;
+    // 业务组件
+    const isBusinessComponent = self.viewElement?.isCorrespondingBusinessComponent;
+    if (isBusinessComponent) {
+      code += `${name}: `;
+    } else if (self?.name === 'data-source' && self?.expression?.concept === 'CallLogic') {
+      code += `() => {\n`;
     } else {
-      code = '() => {';
+      code += '() => {\n';
     }
     if (['destination', 'externalDestination'].includes(name) && type === 'dynamic') {
       code += yield* (self as any)[name].toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
@@ -1100,7 +1104,7 @@ export class BindAttribute extends BaseNode {
       });
     } else if (expression) {
       code += yield* expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-      code += ';\n';
+      code += '\n';
     } else if (name === 'url' && value) {
       /**
        * ls定制化处理
@@ -1126,13 +1130,15 @@ export class BindAttribute extends BaseNode {
         code += ';\n';
       }
     }
-    if (type === 'dynamic') {
+    if (type === 'dynamic' && !isBusinessComponent) {
       yield* wrapForEach(playground, function* warpForEachGenerator(item, index) {
         code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
         code += ';\n';
       });
     }
-    code += '}';
+    if (!isBusinessComponent) {
+      code += '\n}';
+    }
     return code;
   }
 
@@ -1168,6 +1174,8 @@ export class BindAttribute extends BaseNode {
         type = `${self.value}`.includes('.') ? 'nasl.core.Decimal' : 'nasl.core.Long';
       } else if (typeof self.value === 'boolean') {
         type = 'nasl.core.Boolean';
+      } else if (['page-size', 'page-number'].includes(self.name) && self.value === null) {
+        type = 'nasl.core.Long'
       }
       code += `${type}`;
     } else {

package/src/concepts/BindDirective__.ts

@@ -629,21 +629,36 @@ export class BindDirective extends BaseNode {
     return str;
   }
 
+  get viewElement() {
+    return this.getAncestor('ViewElement') as ViewElement;
+  }
+
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
-    let code = '()=>{';
+    // 业务组件
+    const isBusinessComponent = self.viewElement?.correspondingBusinessComponent;
+    let code = '';
+    if (!isBusinessComponent) {
+      code += '()=>{';
+    }
     if (self.expression) {
       code += yield* self.expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-      code += ';\n';
+      code += '\n';
     }
     if (self.type === 'dynamic') {
       yield* wrapForEach(self.playground, function* warpForEachGenerator(item, index) {
         code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-        if (index !== self.playground.length - 1) code += ';\n';
+        if (index !== self.playground.length - 1) code += '\n';
       });
     }
-    code += '}';
+    if (isBusinessComponent) {
+      if (code) {
+        code = `${self.name === 'if' ? '__NASLIF' : self.name}: ${code}`;
+      }
+    } else {
+      code += '}';
+    }
     return code;
   }