@lcap/nasl 3.5.0-beta.4 → 3.6.0-alpha.1

package/src/concepts/App__.ts

@@ -1,13 +1,14 @@
 import { queryNodeByPath } from '../service/storage/jsoner';
 import { getNaslNodeByNodeCallee, getNodeByNodeCallee } from '../automate/engine/utils';
-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 ConfigProperty from './ConfigProperty__';
+import TypeAnnotation from './TypeAnnotation__';
+import View from './View__';
+import AuthInterface from './AuthInterface__';
+import Interface from './Interface__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
+// import CallLogic from './CallLogic__';
+
 export interface AssetsInfo {
   js: Array<string>;
   css: Array<string>;
@@ -33,6 +34,13 @@ interface compilerInfoMapProps {
   js?: { prefix: string };
 }
 
+type composeCacheType = {
+  [key: string]: composeCacheType,
+} & {
+  nodes?: any[];
+};
+
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -51,7 +59,7 @@ import type Enum from './Enum__';
 import type Logic from './Logic__';
 import type OverriddenLogic from './OverriddenLogic__';
 import type AbstractInterface from './AbstractInterface__';
-import type FrontendType from './FrontendType__';
+import type Frontend from './Frontend__';
 import Backend from './Backend__';
 import type Process from './Process__';
 import type Role from './Role__';
@@ -198,14 +206,14 @@ export class App extends BaseNode {
   interfaces: Array<AbstractInterface> = [];
 
   /**
-   * 端类型列表
+   * 前端列表
    */
   @property({
-    objectRef: 'FrontendType',
+    objectRef: 'Frontend',
     isArray: true,
     defaultValue: [],
   })
-  frontendTypes: Array<FrontendType> = [];
+  frontends: Array<Frontend> = [];
 
   /**
    * 后端
@@ -1463,158 +1471,156 @@ export class App extends BaseNode {
     return utils.unique(name, this.getAbstractInterfaceExistingNames(), undefined, true);
   }
 
-  getFrontendTypeExistingNames(excludedList: Array<FrontendType> = []) {
+  getFrontendExistingNames(excludedList: Array<Frontend> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontendTypes as FrontendType[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
   }
-  getFrontendTypeUniqueName(name = 'frontendType1') {
-    return utils.unique(name, this.getFrontendTypeExistingNames(), undefined, true);
+  getFrontendUniqueName(name = 'frontend1') {
+    return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
   }
 
   /**
-   * 插入端类型
+   * 插入前端
    * @internal
-   * @param name 端类型名称，如果不填会自动生成一个唯一名称
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  _insertFrontendTypeAt(name: string, index: number): FrontendType;
+  _insertFrontendAt(name: string, index: number): Frontend;
 
   /**
-   * 插入端类型
+   * 插入前端
    * @internal
-   * @param frontendTypeOptions 端类型参数
+   * @param frontendOptions 前端参数
    */
-  _insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
+  _insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
 
   /**
-   * 插入端类型
+   * 插入前端
    * @internal
-   * @param frontendType 已有的端类型实例
+   * @param frontend 已有的前端实例
    */
-  _insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
+  _insertFrontendAt(frontend: Frontend, index: number): 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;
+  _insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
+    const frontendOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'frontends' };
+    const Frontend = getConceptConstructor('Frontend');
+    let frontend: Frontend;
     if (!options) {
-      frontendType = FrontendType.from(
+      frontend = Frontend.from(
         {
-          ...frontendTypeOptions,
-          name: this.getFrontendTypeUniqueName(),
+          ...frontendOptions,
+          name: this.getFrontendUniqueName(),
         },
         this,
-        'frontendTypes',
+        'frontends',
       );
     } else if (typeof options === 'string') {
-      frontendType = FrontendType.from(
+      frontend = Frontend.from(
         {
-          ...frontendTypeOptions,
+          ...frontendOptions,
           name: options,
         },
         this,
-        'frontendTypes',
+        'frontends',
       );
-    } else if (asserts.isFrontendType(options)) {
+    } else if (asserts.isFrontend(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      frontendType = options;
-      Object.assign(frontendType, relationOptions);
+      frontend = options;
+      Object.assign(frontend, relationOptions);
     } else {
-      frontendType = FrontendType.from(
+      frontend = Frontend.from(
         {
-          ...frontendTypeOptions,
+          ...frontendOptions,
           ...options,
         },
         this,
-        'frontendTypes',
+        'frontends',
       );
     }
-    this.frontendTypes.splice(index, 0, frontendType);
-    return frontendType;
+    this.frontends.splice(index, 0, frontend);
+    return frontend;
   }
 
   /**
-   * 插入端类型
-   * @param name 端类型名称，如果不填会自动生成一个唯一名称
+   * 插入前端
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  insertFrontendTypeAt(name: string, index: number): FrontendType;
+  insertFrontendAt(name: string, index: number): Frontend;
 
   /**
-   * 插入端类型
-   * @param frontendTypeOptions 端类型参数
+   * 插入前端
+   * @param frontendOptions 前端参数
    */
-  insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
+  insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
 
   /**
-   * 插入端类型
-   * @param frontendType 已有的端类型实例
+   * 插入前端
+   * @param frontend 已有的前端实例
    */
-  insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
+  insertFrontendAt(frontend: Frontend, index: number): Frontend;
 
-  insertFrontendTypeAt(options: string | Partial<FrontendType> | FrontendType, index: number) {
-    const node = this._insertFrontendTypeAt(options as any, index);
+  insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
+    const node = this._insertFrontendAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontendTypes',
+      parentKey: 'frontends',
     });
     return node;
   }
 
   /**
-   * 添加端类型
+   * 添加前端
    * @internal
-   * @param name 端类型名称，如果不填会自动生成一个唯一名称
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  _addFrontendType(name?: string): FrontendType;
+  _addFrontend(name?: string): Frontend;
 
   /**
-   * 添加端类型
+   * 添加前端
    * @internal
-   * @param frontendTypeOptions 端类型参数
+   * @param frontendOptions 前端参数
    */
-  _addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
+  _addFrontend(frontendOptions: Partial<Frontend>): Frontend;
 
   /**
-   * 添加端类型
+   * 添加前端
    * @internal
-   * @param frontendType 已有的端类型实例
+   * @param frontend 已有的前端实例
    */
-  _addFrontendType(frontendType: FrontendType): FrontendType;
+  _addFrontend(frontend: Frontend): Frontend;
 
-  _addFrontendType(options?: string | Partial<FrontendType> | FrontendType) {
-    const index = this.frontendTypes.length;
-    return this._insertFrontendTypeAt(options as any, index);
+  _addFrontend(options?: string | Partial<Frontend> | Frontend) {
+    const index = this.frontends.length;
+    return this._insertFrontendAt(options as any, index);
   }
 
   /**
-   * 添加端类型
+   * 添加前端
    * @internal
-   * @param name 端类型名称，如果不填会自动生成一个唯一名称
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  addFrontendType(name?: string): FrontendType;
+  addFrontend(name?: string): Frontend;
 
   /**
-   * 添加端类型
-   * @param frontendTypeOptions 端类型参数
+   * 添加前端
+   * @param frontendOptions 前端参数
    */
-  addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
+  addFrontend(frontendOptions: Partial<Frontend>): Frontend;
 
   /**
-   * 添加端类型
-   * @param frontendType 已有的端类型实例
+   * 添加前端
+   * @param frontend 已有的前端实例
    */
-  addFrontendType(frontendType: FrontendType): FrontendType;
+  addFrontend(frontend: Frontend): Frontend;
 
-  addFrontendType(options?: string | Partial<FrontendType> | FrontendType) {
-    const node = this._addFrontendType(options as any);
-    const index = this.frontendTypes.indexOf(node);
+  addFrontend(options?: string | Partial<Frontend> | Frontend) {
+    const node = this._addFrontend(options as any);
+    const index = this.frontends.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontendTypes',
+      parentKey: 'frontends',
     });
     return node;
   }
@@ -3232,45 +3238,45 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除端类型
-   * @param name 端类型名称
+   * 删除前端
+   * @param name 前端名称
    */
-  removeFrontendType(name: string): void;
+  removeFrontend(name: string): void;
 
   /**
-   * 删除端类型
-   * @param frontendType 已有的端类型实例
+   * 删除前端
+   * @param frontend 已有的前端实例
    */
-  removeFrontendType(frontendType: FrontendType): void;
+  removeFrontend(frontend: Frontend): void;
 
-  removeFrontendType(options: string | FrontendType) {
-    let frontendType: FrontendType;
+  removeFrontend(options: string | Frontend) {
+    let frontend: Frontend;
     if (typeof options === 'string') {
-      frontendType = (this.frontendTypes as FrontendType[]).find((item) => item.name === options);
-      if (!frontendType) {
-        throw new Error('找不到端类型 ' + options);
+      frontend = (this.frontends as Frontend[]).find((item) => item.name === options);
+      if (!frontend) {
+        throw new Error('找不到前端 ' + options);
       }
     } else {
-      frontendType = options;
+      frontend = options;
     }
-    return frontendType.delete();
+    return frontend.delete();
   }
 
-  __removeFrontendType(frontendType: FrontendType) {
-    const parentKey = frontendType.parentKey;
+  __removeFrontend(frontend: Frontend) {
+    const parentKey = frontend.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: frontendType,
+      oldObject: frontend,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = frontendType.__v_raw || frontendType;
+      const n = frontend.__v_raw || frontend;
       if (Array.isArray((t as any)[parentKey])) {
         // @ts-ignore
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
@@ -3926,6 +3932,105 @@ export class App extends BaseNode {
   @property()
   preferenceMap: Record<string, string> = {};
 
+  /**
+   * 组合节点缓存
+   */
+  composeCache: composeCacheType = {};
+
+
+  /**
+   * 获取组合节点
+   */
+  getComposeNodes(path: string[]) {
+    let compose = this.composeCache;
+    path.forEach((key) => {
+      compose = compose?.[key];
+    });
+    return compose?.nodes || [];
+  }
+
+  /**
+   * 往组合内添加节点
+   */
+  addComposeNodes(path: string[], node: BaseNode | BaseNode[]) {
+    let compose = this.composeCache;
+    path.forEach((key, index) => {
+      if (index === path.length - 1) {
+        if (compose?.[key]?.nodes) {
+          if (Array.isArray(node)) {
+            compose[key].nodes.push(...node);
+          } else {
+            compose[key].nodes.push(node);
+          }
+        } else {
+          if (!compose?.[key]) {
+            compose[key] = {};
+          }
+          compose[key].nodes = Array.isArray(node) ? node : [node];
+        }
+      } else {
+        if (!compose?.[key]) {
+          compose[key] = {};
+        }
+        compose = compose[key];
+      }
+    });
+  }
+
+  /**
+   * 删除分组, 包括子集
+   */
+  deleteCompose(path: string[]) {
+    if (!Array.isArray(path)) return;
+    let compose = this.composeCache;
+
+    const delNodes = (_compose: composeCacheType) => {
+      if (_compose?.nodes) {
+        for(let key in _compose) {
+          if (key !== 'nodes') {
+            delNodes(_compose[key]);
+          }
+        }
+        _compose.nodes.forEach((node) => {
+          node.delete();
+        })
+        _compose.nodes = [];
+      }
+    }
+
+    this.emit('collect:start', {
+      actionMsg: '删除同一分组节点',
+    });
+    path.forEach((key, index) => {
+      if (index === path.length - 1) {
+        delNodes(compose?.[key]);
+      } else {
+        compose = compose[key];
+      }
+    });
+    this.emit('collect:end');
+  }
+
+  /**
+   * 释放分组内所有节点
+   */
+  releaseComposeNode(path: string[]) {
+    if (!Array.isArray(path)) return;
+    let compose = this.composeCache;
+    path.forEach((key, index) => {
+      if (index === path.length - 1) {
+        const nodes = compose?.[key]?.nodes || [];
+        nodes.forEach((node) => {
+          node.update({
+            composedBy: [],
+          });
+        })
+      } else {
+        compose = compose[key];
+      }
+    });
+  }
+
   /**
    * 获取命名空间
    */
@@ -3998,21 +4103,23 @@ export class App extends BaseNode {
   }
 
   loadPackageInfo(scope: string) {
-    const dependencyMap = (window as any).globalData.ideVersionDetail.dependencies;
+    const materialConfig = (window as any).globalData.materialConfig || {};
+    const { framework, ui } = materialConfig;
+
     const packageInfo = {
       template: { name: '', version: '', scope },
       ui: { name: '', version: '', scope },
       scope,
     };
 
-    packageInfo.template.name = scope === 'h5' ? '@lcap/mobile-template' : 'lcap-pc-template';
-    packageInfo.template.version =
-      scope === 'h5' ? dependencyMap.FrontendArchH5.version : dependencyMap.FrontendArchPC.version;
-    packageInfo.ui.name = scope === 'h5' ? '@lcap/mobile-ui' : 'cloud-ui.vusion';
-    packageInfo.ui.version =
-      scope === 'h5'
-        ? dependencyMap.FrontendComponentLibraryH5.version
-        : dependencyMap.FrontendComponentLibraryPC.version;
+    packageInfo.template.name = scope === 'h5' ? framework.h5 : framework.pc;
+    packageInfo.template.version = framework.version;
+
+    packageInfo.ui.name = scope === 'h5' ? ui.h5.name : ui.pc.name;
+    packageInfo.ui.version = scope === 'h5'
+        ? ui.h5.version
+        : ui.pc.version;
+
     return packageInfo;
   }
 
@@ -4047,21 +4154,13 @@ export class App extends BaseNode {
           `${prefix}/packages/vue@2/dist/vue.min.js`,
           // `${prefix}/packages/vue-router@3/dist/vue-router.min.js`,
 
-          scope === 'h5'
-            ? `${prefix}/packages/@lcap/mobile-ui@${packageInfo.ui.version}/dist-theme/index.js`
-            : `${prefix}/packages/cloud-ui.vusion@${packageInfo.ui.version}/dist-theme/index.js`,
+          `${prefix}/packages/${packageInfo.ui.name}@${packageInfo.ui.version}/dist-theme/index.js`,
 
-          scope === 'h5'
-            ? `${prefix}/packages/@lcap/mobile-template@${packageInfo.template.version}/cloudAdminDesigner.umd.min.js`
-            : `${prefix}/packages/lcap-pc-template@${packageInfo.template.version}/cloudAdminDesigner.umd.min.js`,
+          `${prefix}/packages/${packageInfo.template.name}@${packageInfo.template.version}/cloudAdminDesigner.umd.min.js`,
         ],
         css: [
-          scope === 'h5'
-            ? `${prefix}/packages/@lcap/mobile-ui@${packageInfo.ui.version}/dist-theme/index.css`
-            : `${prefix}/packages/cloud-ui.vusion@${packageInfo.ui.version}/dist-theme/index.css`,
-          scope === 'h5'
-            ? `${prefix}/packages/@lcap/mobile-template@${packageInfo.template.version}/cloudAdminDesigner.css`
-            : `${prefix}/packages/lcap-pc-template@${packageInfo.template.version}/cloudAdminDesigner.css`,
+          `${prefix}/packages/${packageInfo.ui.name}@${packageInfo.ui.version}/dist-theme/index.css`,
+          `${prefix}/packages/${packageInfo.template.name}@${packageInfo.template.version}/cloudAdminDesigner.css`,
         ],
       },
       custom: {
@@ -4070,10 +4169,10 @@ export class App extends BaseNode {
         names: [],
       },
     };
-    const frontendTypes = this.frontendTypes.filter((frontendType) => frontendType.kind === scope);
+    const frontends = this.frontends.filter((frontend) => frontend.type === scope);
     const existingSet = new Set();
-    frontendTypes.forEach((frontendType) => {
-      frontendType.componentDependencies.forEach((dep) => {
+    frontends.forEach((frontend) => {
+      frontend.componentDependencies.forEach((dep) => {
         const { name, version } = dep;
         const jsName = `${prefix}/packages/${name}@${version}/dist-theme/index.js`;
         if (!existingSet.has(jsName)) {
@@ -4180,11 +4279,7 @@ export class App extends BaseNode {
       structureCount: this.structures.length,
       enumCount: this.enums.length,
       logicCount: this.logics.length,
-      viewCount: sum(
-        this.frontendTypes.map((frontendType) =>
-          sum(frontendType.frontends.map((frontend) => countView(frontend.views))),
-        ),
-      ),
+      viewCount: sum(this.frontends.map((frontend) => countView(frontend.views))),
       processCount: this.processes.length,
     };
   }
@@ -4356,19 +4451,35 @@ 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.frontendTypes || [])
-      .map((frontendType) => frontendType.frontends?.filter((item) => !excludedSet.has(item)).map((item) => item.title))
-      .flat(2);
+    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
   }
 
   getExtensionsCallbackLogics() {
     let resultLogics: string[] = [];
-    this.frontendTypes.forEach((frontendType) => {
-      frontendType?.frontends?.forEach((frontend) => {
-        resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
-      });
+    this.frontends.forEach((frontend) => {
+      resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
     });
     return Array.from(new Set(resultLogics));
   }
@@ -4382,6 +4493,7 @@ export class App extends BaseNode {
   }
 
   genAllCustomComponents() {
+    const { frontends } = this;
     const compMap: {
       pc: Array<any>;
       h5: Array<any>;
@@ -4390,12 +4502,12 @@ export class App extends BaseNode {
       h5: [],
     };
     const existingSet = new Set();
-    this.frontendTypes.forEach((frontendType) => {
-      if (frontendType.componentDependencies) {
-        frontendType.componentDependencies.forEach((dep) => {
+    frontends.forEach((frontend) => {
+      if (frontend.componentDependencies) {
+        frontend.componentDependencies.forEach((dep) => {
           const { name } = dep;
           if (!existingSet.has(name)) {
-            compMap[frontendType.kind].push(dep);
+            compMap[frontend.type].push(dep);
           }
         });
       }

package/src/concepts/BackendVariable__.ts

@@ -321,20 +321,12 @@ 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(typeKind) || typeName === 'DateTime');
+      (!['primitive', 'union'].includes(typeAnnotation.typeKind) || typeAnnotation.typeName === 'DateTime');
     let code = `${this.name} =`;
     if (needGenInitFromSchema) {
-      code += `${context}.$genInitFromSchema('${sortedTypeKey}',`;
+      code += `${context}.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;
     }
 
     if (this.defaultValue?.expression) {