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

package/src/concepts/FrontendType__.ts

@@ -0,0 +1,919 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
+import { createCompilerState, withSourceMapGenerator, TranslatorGenerator } from '../translator';
+import Namespace from './Namespace__';
+import { AssetsInfo } from './App__';
+
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+
+import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import { v4 as uuidv4 } from 'uuid';
+import BaseNode from '../common/BaseNode';
+import type Frontend from './Frontend__';
+import type BusinessComponent from './BusinessComponent__';
+import type Module from './Module__';
+
+/**
+ * 端类型
+ */
+@concept('端类型')
+export class FrontendType extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'FrontendType';
+
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'FrontendType';
+
+  /**
+   * 名称与type保持一致
+   */
+  @property()
+  name!: 'pc' | 'h5';
+
+  /**
+   * PC/H5 端
+   */
+  @property()
+  kind!: 'pc' | 'h5';
+
+  /**
+   * 前端列表
+   */
+  @property({
+    objectRef: 'Frontend',
+    isArray: true,
+    defaultValue: [],
+  })
+  frontends: Array<Frontend> = [];
+
+  /**
+   * 业务组件列表
+   */
+  @property({
+    objectRef: 'BusinessComponent',
+    isArray: true,
+    defaultValue: [],
+  })
+  businessComponents: Array<BusinessComponent> = [];
+
+  /**
+   * 扩展组件列表（兼容老版）
+   */
+  @property({
+    objectRef: 'Module',
+    isArray: true,
+    defaultValue: [],
+  })
+  componentDependencies: Array<Module> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<FrontendType>) {
+    source = Object.assign({}, FrontendType.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): FrontendType {
+    return super.from(source, parentNode, parentKey) as FrontendType;
+  }
+
+  /**
+   * 从父级删除该节点
+   * @internal
+   */
+  _delete() {
+    let params: Params = null;
+    if (this.parentNode) {
+      params = (this.parentNode as any)?.__removeFrontendType?.(this);
+    }
+    return params;
+  }
+
+  getFrontendExistingNames(excludedList: Array<Frontend> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+  }
+  getFrontendUniqueName(name = 'frontend1') {
+    return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
+  }
+
+  /**
+   * 插入前端
+   * @internal
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   */
+  _insertFrontendAt(name: string, index: number): Frontend;
+
+  /**
+   * 插入前端
+   * @internal
+   * @param frontendOptions 前端参数
+   */
+  _insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+
+  /**
+   * 插入前端
+   * @internal
+   * @param frontend 已有的前端实例
+   */
+  _insertFrontendAt(frontend: Frontend, index: number): Frontend;
+
+  _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) {
+      frontend = Frontend.from(
+        {
+          ...frontendOptions,
+          name: this.getFrontendUniqueName(),
+        },
+        this,
+        'frontends',
+      );
+    } else if (typeof options === 'string') {
+      frontend = Frontend.from(
+        {
+          ...frontendOptions,
+          name: options,
+        },
+        this,
+        'frontends',
+      );
+    } else if (asserts.isFrontend(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      frontend = options;
+      Object.assign(frontend, relationOptions);
+    } else {
+      frontend = Frontend.from(
+        {
+          ...frontendOptions,
+          ...options,
+        },
+        this,
+        'frontends',
+      );
+    }
+    this.frontends.splice(index, 0, frontend);
+    return frontend;
+  }
+
+  /**
+   * 插入前端
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   */
+  insertFrontendAt(name: string, index: number): Frontend;
+
+  /**
+   * 插入前端
+   * @param frontendOptions 前端参数
+   */
+  insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+
+  /**
+   * 插入前端
+   * @param frontend 已有的前端实例
+   */
+  insertFrontendAt(frontend: Frontend, index: number): Frontend;
+
+  insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
+    const node = this._insertFrontendAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'frontends',
+    });
+    return node;
+  }
+
+  /**
+   * 添加前端
+   * @internal
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   */
+  _addFrontend(name?: string): Frontend;
+
+  /**
+   * 添加前端
+   * @internal
+   * @param frontendOptions 前端参数
+   */
+  _addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+
+  /**
+   * 添加前端
+   * @internal
+   * @param frontend 已有的前端实例
+   */
+  _addFrontend(frontend: Frontend): Frontend;
+
+  _addFrontend(options?: string | Partial<Frontend> | Frontend) {
+    const index = this.frontends.length;
+    return this._insertFrontendAt(options as any, index);
+  }
+
+  /**
+   * 添加前端
+   * @internal
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   */
+  addFrontend(name?: string): Frontend;
+
+  /**
+   * 添加前端
+   * @param frontendOptions 前端参数
+   */
+  addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+
+  /**
+   * 添加前端
+   * @param frontend 已有的前端实例
+   */
+  addFrontend(frontend: Frontend): Frontend;
+
+  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: 'frontends',
+    });
+    return node;
+  }
+
+  getBusinessComponentExistingNames(excludedList: Array<BusinessComponent> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.businessComponents as BusinessComponent[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item?.name);
+  }
+  getBusinessComponentUniqueName(name = 'component1') {
+    return utils.unique(name, this.getBusinessComponentExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入业务组件
+   * @internal
+   * @param name 业务组件名称，如果不填会自动生成一个唯一名称
+   */
+  _insertBusinessComponentAt(name: string, index: number): BusinessComponent;
+
+  /**
+   * 插入业务组件
+   * @internal
+   * @param componentOptions 业务组件参数
+   */
+  _insertBusinessComponentAt(componentOptions: Partial<BusinessComponent>, index: number): BusinessComponent;
+
+  /**
+   * 插入业务组件
+   * @internal
+   * @param component 已有的业务组件实例
+   */
+  _insertBusinessComponentAt(component: BusinessComponent, index: number): BusinessComponent;
+
+  _insertBusinessComponentAt(options: string | Partial<BusinessComponent> | BusinessComponent, index: number) {
+    const componentOptions: any = this.getBusinessComponentOptions();
+    const relationOptions = { parentNode: this, parentKey: 'businessComponents' };
+    const BusinessComponent = getConceptConstructor('BusinessComponent');
+    let component: BusinessComponent;
+    if (!options) {
+      component = BusinessComponent.from(
+        {
+          ...componentOptions,
+          name: this.getBusinessComponentUniqueName(),
+        },
+        this,
+        'businessComponents',
+      );
+    } else if (typeof options === 'string') {
+      component = BusinessComponent.from(
+        {
+          ...componentOptions,
+          name: options,
+        },
+        this,
+        'businessComponents',
+      );
+    } else if (asserts.isBusinessComponent(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      component = options;
+      Object.assign(component, relationOptions);
+    } else {
+      component = BusinessComponent.from(
+        {
+          ...componentOptions,
+          ...options,
+        },
+        this,
+        'businessComponents',
+      );
+    }
+    this.businessComponents.splice(index, 0, component);
+    return component;
+  }
+
+  /**
+   * 插入业务组件
+   * @param name 业务组件名称，如果不填会自动生成一个唯一名称
+   */
+  insertBusinessComponentAt(name: string, index: number): BusinessComponent;
+
+  /**
+   * 插入业务组件
+   * @param componentOptions 业务组件参数
+   */
+  insertBusinessComponentAt(componentOptions: Partial<BusinessComponent>, index: number): BusinessComponent;
+
+  /**
+   * 插入业务组件
+   * @param component 已有的业务组件实例
+   */
+  insertBusinessComponentAt(component: BusinessComponent, index: number): BusinessComponent;
+
+  insertBusinessComponentAt(options: string | Partial<BusinessComponent> | BusinessComponent, index: number) {
+    const node = this._insertBusinessComponentAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'businessComponents',
+    });
+    return node;
+  }
+
+  /**
+   * 添加业务组件
+   * @internal
+   * @param name 业务组件名称，如果不填会自动生成一个唯一名称
+   */
+  _addBusinessComponent(name?: string): BusinessComponent;
+
+  /**
+   * 添加业务组件
+   * @internal
+   * @param componentOptions 业务组件参数
+   */
+  _addBusinessComponent(componentOptions: Partial<BusinessComponent>): BusinessComponent;
+
+  /**
+   * 添加业务组件
+   * @internal
+   * @param component 已有的业务组件实例
+   */
+  _addBusinessComponent(component: BusinessComponent): BusinessComponent;
+
+  _addBusinessComponent(options?: string | Partial<BusinessComponent> | BusinessComponent) {
+    const index = this.businessComponents.length;
+    return this._insertBusinessComponentAt(options as any, index);
+  }
+
+  /**
+   * 添加业务组件
+   * @internal
+   * @param name 业务组件名称，如果不填会自动生成一个唯一名称
+   */
+  addBusinessComponent(name?: string): BusinessComponent;
+
+  /**
+   * 添加业务组件
+   * @param componentOptions 业务组件参数
+   */
+  addBusinessComponent(componentOptions: Partial<BusinessComponent>): BusinessComponent;
+
+  /**
+   * 添加业务组件
+   * @param component 已有的业务组件实例
+   */
+  addBusinessComponent(component: BusinessComponent): BusinessComponent;
+
+  addBusinessComponent(options?: string | Partial<BusinessComponent> | BusinessComponent) {
+    const node = this._addBusinessComponent(options as any);
+    const index = this.businessComponents.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'businessComponents',
+    });
+    return node;
+  }
+
+  getModuleExistingNames(excludedList: Array<Module> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.componentDependencies as Module[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item?.name);
+  }
+  getModuleUniqueName(name = 'module1') {
+    return utils.unique(name, this.getModuleExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入模块
+   * @internal
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   */
+  _insertModuleAt(name: string, index: number): Module;
+
+  /**
+   * 插入模块
+   * @internal
+   * @param moduleOptions 模块参数
+   */
+  _insertModuleAt(moduleOptions: Partial<Module>, index: number): Module;
+
+  /**
+   * 插入模块
+   * @internal
+   * @param module 已有的模块实例
+   */
+  _insertModuleAt(module: Module, index: number): Module;
+
+  _insertModuleAt(options: string | Partial<Module> | Module, index: number) {
+    const moduleOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'componentDependencies' };
+    const Module = getConceptConstructor('Module');
+    let module: Module;
+    if (!options) {
+      module = Module.from(
+        {
+          ...moduleOptions,
+          name: this.getModuleUniqueName(),
+        },
+        this,
+        'componentDependencies',
+      );
+    } else if (typeof options === 'string') {
+      module = Module.from(
+        {
+          ...moduleOptions,
+          name: options,
+        },
+        this,
+        'componentDependencies',
+      );
+    } else if (asserts.isModule(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      module = options;
+      Object.assign(module, relationOptions);
+    } else {
+      module = Module.from(
+        {
+          ...moduleOptions,
+          ...options,
+        },
+        this,
+        'componentDependencies',
+      );
+    }
+    this.componentDependencies.splice(index, 0, module);
+    return module;
+  }
+
+  /**
+   * 插入模块
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   */
+  insertModuleAt(name: string, index: number): Module;
+
+  /**
+   * 插入模块
+   * @param moduleOptions 模块参数
+   */
+  insertModuleAt(moduleOptions: Partial<Module>, index: number): Module;
+
+  /**
+   * 插入模块
+   * @param module 已有的模块实例
+   */
+  insertModuleAt(module: Module, index: number): Module;
+
+  insertModuleAt(options: string | Partial<Module> | Module, index: number) {
+    const node = this._insertModuleAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'componentDependencies',
+    });
+    return node;
+  }
+
+  /**
+   * 添加模块
+   * @internal
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   */
+  _addModule(name?: string): Module;
+
+  /**
+   * 添加模块
+   * @internal
+   * @param moduleOptions 模块参数
+   */
+  _addModule(moduleOptions: Partial<Module>): Module;
+
+  /**
+   * 添加模块
+   * @internal
+   * @param module 已有的模块实例
+   */
+  _addModule(module: Module): Module;
+
+  _addModule(options?: string | Partial<Module> | Module) {
+    const index = this.componentDependencies.length;
+    return this._insertModuleAt(options as any, index);
+  }
+
+  /**
+   * 添加模块
+   * @internal
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   */
+  addModule(name?: string): Module;
+
+  /**
+   * 添加模块
+   * @param moduleOptions 模块参数
+   */
+  addModule(moduleOptions: Partial<Module>): Module;
+
+  /**
+   * 添加模块
+   * @param module 已有的模块实例
+   */
+  addModule(module: Module): Module;
+
+  addModule(options?: string | Partial<Module> | Module) {
+    const node = this._addModule(options as any);
+    const index = this.componentDependencies.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'componentDependencies',
+    });
+    return node;
+  }
+
+  /**
+   * 删除前端
+   * @param name 前端名称
+   */
+  removeFrontend(name: string): void;
+
+  /**
+   * 删除前端
+   * @param frontend 已有的前端实例
+   */
+  removeFrontend(frontend: Frontend): void;
+
+  removeFrontend(options: string | Frontend) {
+    let frontend: Frontend;
+    if (typeof options === 'string') {
+      frontend = (this.frontends as Frontend[]).find((item) => item.name === options);
+      if (!frontend) {
+        throw new Error('找不到前端 ' + options);
+      }
+    } else {
+      frontend = options;
+    }
+    return frontend.delete();
+  }
+
+  __removeFrontend(frontend: Frontend) {
+    const parentKey = frontend.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: frontend,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      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);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除业务组件
+   * @param name 业务组件名称
+   */
+  removeBusinessComponent(name: string): void;
+
+  /**
+   * 删除业务组件
+   * @param component 已有的业务组件实例
+   */
+  removeBusinessComponent(component: BusinessComponent): void;
+
+  removeBusinessComponent(options: string | BusinessComponent) {
+    let component: BusinessComponent;
+    if (typeof options === 'string') {
+      component = (this.businessComponents as BusinessComponent[]).find((item) => item.name === options);
+      if (!component) {
+        throw new Error('找不到业务组件 ' + options);
+      }
+    } else {
+      component = options;
+    }
+    return component.delete();
+  }
+
+  __removeBusinessComponent(component: BusinessComponent) {
+    const parentKey = component.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: component,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = component.__v_raw || component;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除模块
+   * @param name 模块名称
+   */
+  removeModule(name: string): void;
+
+  /**
+   * 删除模块
+   * @param module 已有的模块实例
+   */
+  removeModule(module: Module): void;
+
+  removeModule(options: string | Module) {
+    let module: Module;
+    if (typeof options === 'string') {
+      module = (this.componentDependencies as Module[]).find((item) => item.name === options);
+      if (!module) {
+        throw new Error('找不到模块 ' + options);
+      }
+    } else {
+      module = options;
+    }
+    return module.delete();
+  }
+
+  __removeModule(module: Module) {
+    const parentKey = module.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: module,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = module.__v_raw || module;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
+      }
+    }
+    return params;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+  getNamespace() {
+    if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
+      const parentNamespace = (this.parentNode as Namespace).getNamespace();
+      const parentName = this.parentNode.name;
+      const arr = [parentNamespace];
+      if (this.parentNode.concept !== 'App' && parentName) {
+        arr.push(parentName);
+      }
+      return `${arr.join('.')}.frontendTypes`;
+    }
+    throw new Error('无法获取命名空间，请设置 parentNode！');
+  }
+
+  /**
+   * 生成宿主语言的文件路径
+   * @param name 一般不用传，用于 rename
+   */
+  getEmbeddedFilePath(name = this.name) {
+    return `/embedded/${this.rootNode?.name || this.parentNode.name}/frontendTypes/${name}.ts`;
+  }
+
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = `export namespace ${self.name} {\n`;
+    code += 'const name = ';
+    code += `"${self.name}";\n`;
+    code += '}\n';
+    return code;
+  }
+
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
+    let code = `namespace ${this.getNamespace()} {\n`;
+
+    const state = createCompilerState(code, { tabSize: 1 });
+    try {
+      code += yield* this.toEmbeddedTS(state);
+    } catch (err) {
+      code += '';
+      console.log(err);
+    }
+    code += '}\n';
+
+    return {
+      code,
+      filePath: this.getEmbeddedFilePath(),
+      sourceMap: state.sourceMap,
+    };
+  }
+
+  /**
+   * 获取业务组件的默认配置
+   * @returns
+   */
+  getBusinessComponentOptions() {
+    let options: any;
+    if (this.kind === 'pc') {
+      options = {
+        elements: [
+          {
+            concept: 'ViewElement',
+            type: 0,
+            tag: 'u-linear-layout',
+            name: 'uLinearLayout1',
+            staticClass: null,
+            slotTarget: null,
+            slotScope: null,
+            bindAttrs: [
+              {
+                concept: 'BindAttribute',
+                name: 'gap',
+                type: 'string',
+                value: 'none',
+                rules: [],
+                playground: [],
+              },
+            ],
+            bindEvents: [],
+            bindDirectives: [],
+            bindRoles: [],
+            bindStyles: [],
+            children: [],
+          },
+        ],
+      };
+    } else {
+      options = {
+        elements: [
+          {
+            concept: 'ViewElement',
+            name: 'vanLinearLayout1',
+            type: 0,
+            tag: 'van-linear-layout',
+            staticStyle: null,
+            slotTarget: null,
+            slotScope: null,
+            bindAttrs: [
+              {
+                concept: 'BindAttribute',
+                name: 'gap',
+                type: 'string',
+                value: 'none',
+                rules: [],
+                playground: [],
+              },
+            ],
+            bindEvents: [],
+            bindDirectives: [],
+            bindRoles: [],
+            bindStyles: [],
+            children: [],
+          },
+        ],
+      };
+    }
+    return options;
+  }
+
+  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;
+  }
+
+  findComponentDependencyByName(name: string) {
+    return this.componentDependencies.find((componentDependency) => componentDependency.name === name);
+  }
+
+  genCustomAssetsInfo(prefix: string) {
+    const custom: AssetsInfo = {
+      js: [],
+      css: [],
+      names: [],
+    };
+    const existingSet = new Set();
+    this.componentDependencies.forEach((dep) => {
+      const { name, version } = dep;
+      const jsName = `${prefix}/packages/${name}@${version}/dist-theme/index.js`;
+      if (!existingSet.has(jsName)) {
+        existingSet.add(jsName);
+        custom.js.push(jsName);
+        if (utils.shouldLoadCss(name, version)) {
+          custom.css.push(`${prefix}/packages/${name}@${version}/dist-theme/index.css`);
+        }
+        custom.names.push(name);
+      }
+    });
+    return custom;
+  }
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default FrontendType;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================