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

package/src/concepts/BusinessComponent__.ts

@@ -1,2669 +0,0 @@
-import {
-  wrapForEachToGenerator as wrapForEach,
-  wrapIteratorToGenerator as wrapIterator,
-  returnOrigin,
-} from '../utils/time-slicing';
-import type { EmbeddedTSFileGenerator } from '../utils';
-import { shiftState, indent, createCompilerState, withSourceMapGenerator, TranslatorGenerator } from '../translator';
-import type Assignment from './Assignment__';
-import type BatchAssignment from './BatchAssignment__';
-import type Interface from './Interface__';
-import type App from './App__';
-import type FrontendType from './FrontendType__';
-import type Match from './Match__';
-import { ElementToVueOptions } from './ViewElement__';
-import translator from '../bak/translator';
-
-type AttrObject = {
-  value: string;
-  label: string;
-};
-
-const PAGE_COMPONENT_INCLUDE_TAG_MAP: Record<string, Record<string, AttrObject>> = {
-  'u-list-view': {
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-grid-view': {
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-list-components': {
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-table-view': {
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-    sorting: {
-      value: 'sort',
-      label: '排序属性',
-    },
-    value: {
-      value: 'value',
-      label: '单选选中值',
-    },
-    values: {
-      value: 'values',
-      label: '多选选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-radios': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-checkboxes': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-select': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-    opened: {
-      value: 'opened',
-      label: '弹出状态',
-    },
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-  },
-  'u-cascader': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'u-tree-select-new': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'van-radio-group': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'van-checkbox-group': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'van-pickerson': {
-    pvalue: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-  },
-  'van-cascader': {
-    value: {
-      value: 'value',
-      label: '选中值',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'van-list-view': {
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'van-grid-view': {
-    'page-size': {
-      value: 'size',
-      label: '分页大小',
-    },
-    'page-number': {
-      value: 'page',
-      label: '当前页数',
-    },
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-  'van-for-components': {
-    'data-source': {
-      value: 'data',
-      label: '数据',
-    },
-  },
-};
-
-const getBranchCopyUniCode = () => (window as any)?.BranchCopyUniCode;
-const removedViewElementCache: {
-  [key: string]: number | bigint;
-} = {}; // 临时记录删除的页面元素计数的最大值
-
-//================================================================================
-// 从这里开始到结尾注释之间的代码由 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 Event from './Event__';
-import type ParamWithGroup from './ParamWithGroup__';
-import type Variable from './Variable__';
-import type BindEvent from './BindEvent__';
-import type BusinessLogic from './BusinessLogic__';
-import type ViewElement from './ViewElement__';
-import type Param from './Param__';
-import type Logic from './Logic__';
-
-/**
- * 业务组件
- */
-@concept('业务组件')
-export class BusinessComponent extends BaseNode {
-  /** 类名 */
-  static readonly ConceptName: string = 'BusinessComponent';
-
-  /** 继承链 */
-  static readonly inheritanceChain: string[] = ['BaseNode'];
-
-  /**
-   * 产品概念
-   */
-  @property('concept')
-  // @ts-ignore
-  readonly concept!: 'BusinessComponent';
-
-  /**
-   * 业务组件名称
-   */
-  @property()
-  name!: string;
-
-  /**
-   * 业务组件标题
-   */
-  @property()
-  title!: string;
-
-  /**
-   * 业务组件描述
-   */
-  @property()
-  description!: string;
-
-  /**
-   * 组件事件列表
-   */
-  @property({
-    objectRef: 'Event',
-    isArray: true,
-    defaultValue: [],
-  })
-  events: Array<Event> = [];
-
-  /**
-   * 参数分组列表
-   */
-  @property({
-    objectRef: 'ParamWithGroup',
-    isArray: true,
-    defaultValue: [],
-  })
-  params: Array<ParamWithGroup> = [];
-
-  /**
-   * 变量列表
-   */
-  @property({
-    objectRef: 'Variable',
-    isArray: true,
-    defaultValue: [],
-  })
-  variables: Array<Variable> = [];
-
-  /**
-   * 元素绑定事件列表
-   */
-  @property({
-    objectRef: 'BindEvent',
-    isArray: true,
-    defaultValue: [],
-  })
-  bindEvents: Array<BindEvent> = [];
-
-  /**
-   * 业务组件逻辑列表
-   */
-  @property({
-    objectRef: 'BusinessLogic',
-    isArray: true,
-    defaultValue: [],
-  })
-  logics: Array<BusinessLogic> = [];
-
-  /**
-   * 页面元素列表
-   */
-  @property({
-    objectRef: 'ViewElement',
-    isArray: true,
-    defaultValue: [],
-  })
-  elements: Array<ViewElement> = [];
-
-  /**
-   * icon
-   */
-  @property()
-  icon!: string;
-
-  /**
-   * @param source 需要合并的部分参数
-   */
-  constructor(source?: Partial<BusinessComponent>) {
-    source = Object.assign({}, BusinessComponent.getDefaultOptions(), source);
-    super(source);
-    super.subConstructor(source);
-  }
-
-  static from(source: any, parentNode?: any, parentKey?: string): BusinessComponent {
-    return super.from(source, parentNode, parentKey) as BusinessComponent;
-  }
-
-  /**
-   * 从父级删除该节点
-   * @internal
-   */
-  _delete() {
-    let params: Params = null;
-    if (this.parentNode) {
-      params = (this.parentNode as any)?.__removeBusinessComponent?.(this);
-    }
-    return params;
-  }
-  /**
-   * 设置业务组件名称
-   */
-  setName(name: string) {
-    const object = {
-      name,
-    };
-    this.update({
-      ...object,
-      field: 'name',
-    });
-  }
-
-  /**
-   * 设置业务组件标题
-   */
-  setTitle(title: string) {
-    const object = {
-      title,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
-  /**
-   * 设置业务组件描述
-   */
-  setDescription(description: string) {
-    const object = {
-      description,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
-  /**
-   * 设置icon
-   */
-  setIcon(icon: string) {
-    const object = {
-      icon,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
-  getEventExistingNames(excludedList: Array<Event> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.events as Event[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
-  }
-  getEventUniqueName(name = 'event1') {
-    return utils.unique(name, this.getEventExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入组件事件
-   * @internal
-   * @param name 组件事件名称，如果不填会自动生成一个唯一名称
-   */
-  _insertEventAt(name: string, index: number): Event;
-
-  /**
-   * 插入组件事件
-   * @internal
-   * @param eventOptions 组件事件参数
-   */
-  _insertEventAt(eventOptions: Partial<Event>, index: number): Event;
-
-  /**
-   * 插入组件事件
-   * @internal
-   * @param event 已有的组件事件实例
-   */
-  _insertEventAt(event: Event, index: number): Event;
-
-  _insertEventAt(options: string | Partial<Event> | Event, index: number) {
-    const eventOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'events' };
-    const Event = getConceptConstructor('Event');
-    let event: Event;
-    if (!options) {
-      event = Event.from(
-        {
-          ...eventOptions,
-          name: this.getEventUniqueName(),
-        },
-        this,
-        'events',
-      );
-    } else if (typeof options === 'string') {
-      event = Event.from(
-        {
-          ...eventOptions,
-          name: options,
-        },
-        this,
-        'events',
-      );
-    } else if (asserts.isEvent(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      event = options;
-      Object.assign(event, relationOptions);
-    } else {
-      event = Event.from(
-        {
-          ...eventOptions,
-          ...options,
-        },
-        this,
-        'events',
-      );
-    }
-    this.events.splice(index, 0, event);
-    return event;
-  }
-
-  /**
-   * 插入组件事件
-   * @param name 组件事件名称，如果不填会自动生成一个唯一名称
-   */
-  insertEventAt(name: string, index: number): Event;
-
-  /**
-   * 插入组件事件
-   * @param eventOptions 组件事件参数
-   */
-  insertEventAt(eventOptions: Partial<Event>, index: number): Event;
-
-  /**
-   * 插入组件事件
-   * @param event 已有的组件事件实例
-   */
-  insertEventAt(event: Event, index: number): Event;
-
-  insertEventAt(options: string | Partial<Event> | Event, index: number) {
-    const node = this._insertEventAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'events',
-    });
-    return node;
-  }
-
-  /**
-   * 添加组件事件
-   * @internal
-   * @param name 组件事件名称，如果不填会自动生成一个唯一名称
-   */
-  _addEvent(name?: string): Event;
-
-  /**
-   * 添加组件事件
-   * @internal
-   * @param eventOptions 组件事件参数
-   */
-  _addEvent(eventOptions: Partial<Event>): Event;
-
-  /**
-   * 添加组件事件
-   * @internal
-   * @param event 已有的组件事件实例
-   */
-  _addEvent(event: Event): Event;
-
-  _addEvent(options?: string | Partial<Event> | Event) {
-    const index = this.events.length;
-    return this._insertEventAt(options as any, index);
-  }
-
-  /**
-   * 添加组件事件
-   * @internal
-   * @param name 组件事件名称，如果不填会自动生成一个唯一名称
-   */
-  addEvent(name?: string): Event;
-
-  /**
-   * 添加组件事件
-   * @param eventOptions 组件事件参数
-   */
-  addEvent(eventOptions: Partial<Event>): Event;
-
-  /**
-   * 添加组件事件
-   * @param event 已有的组件事件实例
-   */
-  addEvent(event: Event): Event;
-
-  addEvent(options?: string | Partial<Event> | Event) {
-    const node = this._addEvent(options as any);
-    const index = this.events.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'events',
-    });
-    return node;
-  }
-
-  getParamUniqueName(name = 'param1') {
-    return utils.unique(name, this.getVarExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入参数分组
-   * @internal
-   * @param name 参数分组名称，如果不填会自动生成一个唯一名称
-   */
-  _insertParamAt(name: string, index: number): ParamWithGroup;
-
-  /**
-   * 插入参数分组
-   * @internal
-   * @param paramOptions 参数分组参数
-   */
-  _insertParamAt(paramOptions: Partial<ParamWithGroup>, index: number): ParamWithGroup;
-
-  /**
-   * 插入参数分组
-   * @internal
-   * @param param 已有的参数分组实例
-   */
-  _insertParamAt(param: ParamWithGroup, index: number): ParamWithGroup;
-
-  _insertParamAt(options: string | Partial<ParamWithGroup> | ParamWithGroup, index: number) {
-    const paramOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'params' };
-    const ParamWithGroup = getConceptConstructor('ParamWithGroup');
-    let param: ParamWithGroup;
-    if (!options) {
-      param = ParamWithGroup.from(
-        {
-          ...paramOptions,
-          name: this.getParamUniqueName(),
-        },
-        this,
-        'params',
-      );
-    } else if (typeof options === 'string') {
-      param = ParamWithGroup.from(
-        {
-          ...paramOptions,
-          name: options,
-        },
-        this,
-        'params',
-      );
-    } else if (asserts.isParamWithGroup(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      param = options;
-      Object.assign(param, relationOptions);
-    } else {
-      param = ParamWithGroup.from(
-        {
-          ...paramOptions,
-          ...options,
-        },
-        this,
-        'params',
-      );
-    }
-    this.params.splice(index, 0, param);
-    return param;
-  }
-
-  /**
-   * 插入参数分组
-   * @param name 参数分组名称，如果不填会自动生成一个唯一名称
-   */
-  insertParamAt(name: string, index: number): ParamWithGroup;
-
-  /**
-   * 插入参数分组
-   * @param paramOptions 参数分组参数
-   */
-  insertParamAt(paramOptions: Partial<ParamWithGroup>, index: number): ParamWithGroup;
-
-  /**
-   * 插入参数分组
-   * @param param 已有的参数分组实例
-   */
-  insertParamAt(param: ParamWithGroup, index: number): ParamWithGroup;
-
-  insertParamAt(options: string | Partial<ParamWithGroup> | ParamWithGroup, index: number) {
-    const node = this._insertParamAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'params',
-    });
-    return node;
-  }
-
-  /**
-   * 添加参数分组
-   * @internal
-   * @param name 参数分组名称，如果不填会自动生成一个唯一名称
-   */
-  _addParam(name?: string): ParamWithGroup;
-
-  /**
-   * 添加参数分组
-   * @internal
-   * @param paramOptions 参数分组参数
-   */
-  _addParam(paramOptions: Partial<ParamWithGroup>): ParamWithGroup;
-
-  /**
-   * 添加参数分组
-   * @internal
-   * @param param 已有的参数分组实例
-   */
-  _addParam(param: ParamWithGroup): ParamWithGroup;
-
-  _addParam(options?: string | Partial<ParamWithGroup> | ParamWithGroup) {
-    const index = this.params.length;
-    return this._insertParamAt(options as any, index);
-  }
-
-  /**
-   * 添加参数分组
-   * @internal
-   * @param name 参数分组名称，如果不填会自动生成一个唯一名称
-   */
-  addParam(name?: string): ParamWithGroup;
-
-  /**
-   * 添加参数分组
-   * @param paramOptions 参数分组参数
-   */
-  addParam(paramOptions: Partial<ParamWithGroup>): ParamWithGroup;
-
-  /**
-   * 添加参数分组
-   * @param param 已有的参数分组实例
-   */
-  addParam(param: ParamWithGroup): ParamWithGroup;
-
-  addParam(options?: string | Partial<ParamWithGroup> | ParamWithGroup) {
-    const node = this._addParam(options as any);
-    const index = this.params.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'params',
-    });
-    return node;
-  }
-
-  getVariableUniqueName(name = 'variable1') {
-    return utils.unique(name, this.getVarExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入变量
-   * @internal
-   * @param name 变量名称，如果不填会自动生成一个唯一名称
-   */
-  _insertVariableAt(name: string, index: number): Variable;
-
-  /**
-   * 插入变量
-   * @internal
-   * @param variableOptions 变量参数
-   */
-  _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
-
-  /**
-   * 插入变量
-   * @internal
-   * @param variable 已有的变量实例
-   */
-  _insertVariableAt(variable: Variable, index: number): Variable;
-
-  _insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
-    const variableOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'variables' };
-    const Variable = getConceptConstructor('Variable');
-    let variable: Variable;
-    if (!options) {
-      variable = Variable.from(
-        {
-          ...variableOptions,
-          name: this.getVariableUniqueName(),
-        },
-        this,
-        'variables',
-      );
-    } else if (typeof options === 'string') {
-      variable = Variable.from(
-        {
-          ...variableOptions,
-          name: options,
-        },
-        this,
-        'variables',
-      );
-    } else if (asserts.isVariable(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      variable = options;
-      Object.assign(variable, relationOptions);
-    } else {
-      variable = Variable.from(
-        {
-          ...variableOptions,
-          ...options,
-        },
-        this,
-        'variables',
-      );
-    }
-    this.variables.splice(index, 0, variable);
-    return variable;
-  }
-
-  /**
-   * 插入变量
-   * @param name 变量名称，如果不填会自动生成一个唯一名称
-   */
-  insertVariableAt(name: string, index: number): Variable;
-
-  /**
-   * 插入变量
-   * @param variableOptions 变量参数
-   */
-  insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
-
-  /**
-   * 插入变量
-   * @param variable 已有的变量实例
-   */
-  insertVariableAt(variable: Variable, index: number): Variable;
-
-  insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
-    const node = this._insertVariableAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'variables',
-    });
-    return node;
-  }
-
-  /**
-   * 添加变量
-   * @internal
-   * @param name 变量名称，如果不填会自动生成一个唯一名称
-   */
-  _addVariable(name?: string): Variable;
-
-  /**
-   * 添加变量
-   * @internal
-   * @param variableOptions 变量参数
-   */
-  _addVariable(variableOptions: Partial<Variable>): Variable;
-
-  /**
-   * 添加变量
-   * @internal
-   * @param variable 已有的变量实例
-   */
-  _addVariable(variable: Variable): Variable;
-
-  _addVariable(options?: string | Partial<Variable> | Variable) {
-    const index = this.variables.length;
-    return this._insertVariableAt(options as any, index);
-  }
-
-  /**
-   * 添加变量
-   * @internal
-   * @param name 变量名称，如果不填会自动生成一个唯一名称
-   */
-  addVariable(name?: string): Variable;
-
-  /**
-   * 添加变量
-   * @param variableOptions 变量参数
-   */
-  addVariable(variableOptions: Partial<Variable>): Variable;
-
-  /**
-   * 添加变量
-   * @param variable 已有的变量实例
-   */
-  addVariable(variable: Variable): Variable;
-
-  addVariable(options?: string | Partial<Variable> | Variable) {
-    const node = this._addVariable(options as any);
-    const index = this.variables.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'variables',
-    });
-    return node;
-  }
-
-  getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.bindEvents as BindEvent[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
-  }
-  getBindEventUniqueName(name = 'bindEvent1') {
-    return utils.unique(name, this.getBindEventExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入元素绑定事件
-   * @internal
-   * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
-   */
-  _insertBindEventAt(name: string, index: number): BindEvent;
-
-  /**
-   * 插入元素绑定事件
-   * @internal
-   * @param bindEventOptions 元素绑定事件参数
-   */
-  _insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
-
-  /**
-   * 插入元素绑定事件
-   * @internal
-   * @param bindEvent 已有的元素绑定事件实例
-   */
-  _insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
-
-  _insertBindEventAt(options: string | Partial<BindEvent> | BindEvent, index: number) {
-    const bindEventOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'bindEvents' };
-    const BindEvent = getConceptConstructor('BindEvent');
-    let bindEvent: BindEvent;
-    if (!options) {
-      bindEvent = BindEvent.from(
-        {
-          ...bindEventOptions,
-          name: this.getBindEventUniqueName(),
-        },
-        this,
-        'bindEvents',
-      );
-    } else if (typeof options === 'string') {
-      bindEvent = BindEvent.from(
-        {
-          ...bindEventOptions,
-          name: options,
-        },
-        this,
-        'bindEvents',
-      );
-    } else if (asserts.isBindEvent(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      bindEvent = options;
-      Object.assign(bindEvent, relationOptions);
-    } else {
-      bindEvent = BindEvent.from(
-        {
-          ...bindEventOptions,
-          ...options,
-        },
-        this,
-        'bindEvents',
-      );
-    }
-    this.bindEvents.splice(index, 0, bindEvent);
-    return bindEvent;
-  }
-
-  /**
-   * 插入元素绑定事件
-   * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
-   */
-  insertBindEventAt(name: string, index: number): BindEvent;
-
-  /**
-   * 插入元素绑定事件
-   * @param bindEventOptions 元素绑定事件参数
-   */
-  insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
-
-  /**
-   * 插入元素绑定事件
-   * @param bindEvent 已有的元素绑定事件实例
-   */
-  insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
-
-  insertBindEventAt(options: string | Partial<BindEvent> | BindEvent, index: number) {
-    const node = this._insertBindEventAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'bindEvents',
-    });
-    return node;
-  }
-
-  /**
-   * 添加元素绑定事件
-   * @internal
-   * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
-   */
-  _addBindEvent(name?: string): BindEvent;
-
-  /**
-   * 添加元素绑定事件
-   * @internal
-   * @param bindEventOptions 元素绑定事件参数
-   */
-  _addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
-
-  /**
-   * 添加元素绑定事件
-   * @internal
-   * @param bindEvent 已有的元素绑定事件实例
-   */
-  _addBindEvent(bindEvent: BindEvent): BindEvent;
-
-  _addBindEvent(options?: string | Partial<BindEvent> | BindEvent) {
-    const index = this.bindEvents.length;
-    return this._insertBindEventAt(options as any, index);
-  }
-
-  /**
-   * 添加元素绑定事件
-   * @internal
-   * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
-   */
-  addBindEvent(name?: string): BindEvent;
-
-  /**
-   * 添加元素绑定事件
-   * @param bindEventOptions 元素绑定事件参数
-   */
-  addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
-
-  /**
-   * 添加元素绑定事件
-   * @param bindEvent 已有的元素绑定事件实例
-   */
-  addBindEvent(bindEvent: BindEvent): BindEvent;
-
-  addBindEvent(options?: string | Partial<BindEvent> | BindEvent) {
-    const node = this._addBindEvent(options as any);
-    const index = this.bindEvents.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'bindEvents',
-    });
-    return node;
-  }
-
-  getLogicExistingNames(excludedList: Array<BusinessLogic> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.logics as BusinessLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
-  }
-  getLogicUniqueName(name = 'logic1') {
-    return utils.unique(name, this.getLogicExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入业务组件逻辑
-   * @internal
-   * @param name 业务组件逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _insertLogicAt(name: string, index: number): BusinessLogic;
-
-  /**
-   * 插入业务组件逻辑
-   * @internal
-   * @param logicOptions 业务组件逻辑参数
-   */
-  _insertLogicAt(logicOptions: Partial<BusinessLogic>, index: number): BusinessLogic;
-
-  /**
-   * 插入业务组件逻辑
-   * @internal
-   * @param logic 已有的业务组件逻辑实例
-   */
-  _insertLogicAt(logic: BusinessLogic, index: number): BusinessLogic;
-
-  _insertLogicAt(options: string | Partial<BusinessLogic> | BusinessLogic, index: number) {
-    const logicOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'logics' };
-    const BusinessLogic = getConceptConstructor('BusinessLogic');
-    let logic: BusinessLogic;
-    if (!options) {
-      logic = BusinessLogic.from(
-        {
-          ...logicOptions,
-          name: this.getLogicUniqueName(),
-        },
-        this,
-        'logics',
-      );
-    } else if (typeof options === 'string') {
-      logic = BusinessLogic.from(
-        {
-          ...logicOptions,
-          name: options,
-        },
-        this,
-        'logics',
-      );
-    } else if (asserts.isBusinessLogic(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      logic = options;
-      Object.assign(logic, relationOptions);
-    } else {
-      logic = BusinessLogic.from(
-        {
-          ...logicOptions,
-          ...options,
-        },
-        this,
-        'logics',
-      );
-    }
-    this.logics.splice(index, 0, logic);
-    return logic;
-  }
-
-  /**
-   * 插入业务组件逻辑
-   * @param name 业务组件逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  insertLogicAt(name: string, index: number): BusinessLogic;
-
-  /**
-   * 插入业务组件逻辑
-   * @param logicOptions 业务组件逻辑参数
-   */
-  insertLogicAt(logicOptions: Partial<BusinessLogic>, index: number): BusinessLogic;
-
-  /**
-   * 插入业务组件逻辑
-   * @param logic 已有的业务组件逻辑实例
-   */
-  insertLogicAt(logic: BusinessLogic, index: number): BusinessLogic;
-
-  insertLogicAt(options: string | Partial<BusinessLogic> | BusinessLogic, index: number) {
-    const node = this._insertLogicAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'logics',
-    });
-    return node;
-  }
-
-  /**
-   * 添加业务组件逻辑
-   * @internal
-   * @param name 业务组件逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _addLogic(name?: string): BusinessLogic;
-
-  /**
-   * 添加业务组件逻辑
-   * @internal
-   * @param logicOptions 业务组件逻辑参数
-   */
-  _addLogic(logicOptions: Partial<BusinessLogic>): BusinessLogic;
-
-  /**
-   * 添加业务组件逻辑
-   * @internal
-   * @param logic 已有的业务组件逻辑实例
-   */
-  _addLogic(logic: BusinessLogic): BusinessLogic;
-
-  _addLogic(options?: string | Partial<BusinessLogic> | BusinessLogic) {
-    const index = this.logics.length;
-    return this._insertLogicAt(options as any, index);
-  }
-
-  /**
-   * 添加业务组件逻辑
-   * @internal
-   * @param name 业务组件逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  addLogic(name?: string): BusinessLogic;
-
-  /**
-   * 添加业务组件逻辑
-   * @param logicOptions 业务组件逻辑参数
-   */
-  addLogic(logicOptions: Partial<BusinessLogic>): BusinessLogic;
-
-  /**
-   * 添加业务组件逻辑
-   * @param logic 已有的业务组件逻辑实例
-   */
-  addLogic(logic: BusinessLogic): BusinessLogic;
-
-  addLogic(options?: string | Partial<BusinessLogic> | BusinessLogic) {
-    const node = this._addLogic(options as any);
-    const index = this.logics.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'logics',
-    });
-    return node;
-  }
-
-  /**
-   * 插入页面元素
-   * @internal
-   * @param name 页面元素名称，如果不填会自动生成一个唯一名称
-   */
-  _insertViewElementAt(name: string, index: number): ViewElement;
-
-  /**
-   * 插入页面元素
-   * @internal
-   * @param viewElementOptions 页面元素参数
-   */
-  _insertViewElementAt(viewElementOptions: Partial<ViewElement>, index: number): ViewElement;
-
-  /**
-   * 插入页面元素
-   * @internal
-   * @param viewElement 已有的页面元素实例
-   */
-  _insertViewElementAt(viewElement: ViewElement, index: number): ViewElement;
-
-  _insertViewElementAt(options: string | Partial<ViewElement> | ViewElement, index: number) {
-    const viewElementOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'elements' };
-    const ViewElement = getConceptConstructor('ViewElement');
-    let viewElement: ViewElement;
-    if (!options) {
-      viewElement = ViewElement.from(
-        {
-          ...viewElementOptions,
-          name: this.getViewElementUniqueName(),
-        },
-        this,
-        'elements',
-      );
-    } else if (typeof options === 'string') {
-      viewElement = ViewElement.from(
-        {
-          ...viewElementOptions,
-          name: options,
-        },
-        this,
-        'elements',
-      );
-    } else if (asserts.isViewElement(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      viewElement = options;
-      Object.assign(viewElement, relationOptions);
-    } else {
-      viewElement = ViewElement.from(
-        {
-          ...viewElementOptions,
-          ...options,
-        },
-        this,
-        'elements',
-      );
-    }
-    this.elements.splice(index, 0, viewElement);
-    return viewElement;
-  }
-
-  /**
-   * 插入页面元素
-   * @param name 页面元素名称，如果不填会自动生成一个唯一名称
-   */
-  insertViewElementAt(name: string, index: number): ViewElement;
-
-  /**
-   * 插入页面元素
-   * @param viewElementOptions 页面元素参数
-   */
-  insertViewElementAt(viewElementOptions: Partial<ViewElement>, index: number): ViewElement;
-
-  /**
-   * 插入页面元素
-   * @param viewElement 已有的页面元素实例
-   */
-  insertViewElementAt(viewElement: ViewElement, index: number): ViewElement;
-
-  insertViewElementAt(options: string | Partial<ViewElement> | ViewElement, index: number) {
-    const node = this._insertViewElementAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'elements',
-    });
-    return node;
-  }
-
-  /**
-   * 添加页面元素
-   * @internal
-   * @param name 页面元素名称，如果不填会自动生成一个唯一名称
-   */
-  _addViewElement(name?: string): ViewElement;
-
-  /**
-   * 添加页面元素
-   * @internal
-   * @param viewElementOptions 页面元素参数
-   */
-  _addViewElement(viewElementOptions: Partial<ViewElement>): ViewElement;
-
-  /**
-   * 添加页面元素
-   * @internal
-   * @param viewElement 已有的页面元素实例
-   */
-  _addViewElement(viewElement: ViewElement): ViewElement;
-
-  _addViewElement(options?: string | Partial<ViewElement> | ViewElement) {
-    const index = this.elements.length;
-    return this._insertViewElementAt(options as any, index);
-  }
-
-  /**
-   * 添加页面元素
-   * @internal
-   * @param name 页面元素名称，如果不填会自动生成一个唯一名称
-   */
-  addViewElement(name?: string): ViewElement;
-
-  /**
-   * 添加页面元素
-   * @param viewElementOptions 页面元素参数
-   */
-  addViewElement(viewElementOptions: Partial<ViewElement>): ViewElement;
-
-  /**
-   * 添加页面元素
-   * @param viewElement 已有的页面元素实例
-   */
-  addViewElement(viewElement: ViewElement): ViewElement;
-
-  addViewElement(options?: string | Partial<ViewElement> | ViewElement) {
-    const node = this._addViewElement(options as any);
-    const index = this.elements.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'elements',
-    });
-    return node;
-  }
-
-  /**
-   * 删除组件事件
-   * @param name 组件事件名称
-   */
-  removeEvent(name: string): void;
-
-  /**
-   * 删除组件事件
-   * @param event 已有的组件事件实例
-   */
-  removeEvent(event: Event): void;
-
-  removeEvent(options: string | Event) {
-    let event: Event;
-    if (typeof options === 'string') {
-      event = (this.events as Event[]).find((item) => item.name === options);
-      if (!event) {
-        throw new Error('找不到组件事件 ' + options);
-      }
-    } else {
-      event = options;
-    }
-    return event.delete();
-  }
-
-  __removeEvent(event: Event) {
-    const parentKey = event.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: event,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = event.__v_raw || event;
-      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 参数分组名称
-   */
-  removeParam(name: string): void;
-
-  /**
-   * 删除参数分组
-   * @param param 已有的参数分组实例
-   */
-  removeParam(param: ParamWithGroup): void;
-
-  removeParam(options: string | ParamWithGroup) {
-    let param: ParamWithGroup;
-    if (typeof options === 'string') {
-      param = (this.params as ParamWithGroup[]).find((item) => item.name === options);
-      if (!param) {
-        throw new Error('找不到参数分组 ' + options);
-      }
-    } else {
-      param = options;
-    }
-    return param.delete();
-  }
-
-  __removeParam(param: Param) {
-    const parentKey = param.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: param,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = param.__v_raw || param;
-      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 变量名称
-   */
-  removeVariable(name: string): void;
-
-  /**
-   * 删除变量
-   * @param variable 已有的变量实例
-   */
-  removeVariable(variable: Variable): void;
-
-  removeVariable(options: string | Variable) {
-    let variable: Variable;
-    if (typeof options === 'string') {
-      variable = (this.variables as Variable[]).find((item) => item.name === options);
-      if (!variable) {
-        throw new Error('找不到变量 ' + options);
-      }
-    } else {
-      variable = options;
-    }
-    return variable.delete();
-  }
-
-  __removeVariable(variable: Variable) {
-    const parentKey = variable.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: variable,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = variable.__v_raw || variable;
-      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 元素绑定事件名称
-   */
-  removeBindEvent(name: string): void;
-
-  /**
-   * 删除元素绑定事件
-   * @param bindEvent 已有的元素绑定事件实例
-   */
-  removeBindEvent(bindEvent: BindEvent): void;
-
-  removeBindEvent(options: string | BindEvent) {
-    let bindEvent: BindEvent;
-    if (typeof options === 'string') {
-      bindEvent = (this.bindEvents as BindEvent[]).find((item) => item.name === options);
-      if (!bindEvent) {
-        throw new Error('找不到元素绑定事件 ' + options);
-      }
-    } else {
-      bindEvent = options;
-    }
-    return bindEvent.delete();
-  }
-
-  __removeBindEvent(bindEvent: BindEvent) {
-    const parentKey = bindEvent.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: bindEvent,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = bindEvent.__v_raw || bindEvent;
-      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 业务组件逻辑名称
-   */
-  removeLogic(name: string): void;
-
-  /**
-   * 删除业务组件逻辑
-   * @param logic 已有的业务组件逻辑实例
-   */
-  removeLogic(logic: BusinessLogic): void;
-
-  removeLogic(options: string | BusinessLogic) {
-    let logic: BusinessLogic;
-    if (typeof options === 'string') {
-      logic = (this.logics as BusinessLogic[]).find((item) => item.name === options);
-      if (!logic) {
-        throw new Error('找不到业务组件逻辑 ' + options);
-      }
-    } else {
-      logic = options;
-    }
-    return logic.delete();
-  }
-
-  __removeLogic(logic: Logic) {
-    const parentKey = logic.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logic,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logic.__v_raw || logic;
-      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 页面元素名称
-   */
-  removeViewElement(name: string): void;
-
-  /**
-   * 删除页面元素
-   * @param viewElement 已有的页面元素实例
-   */
-  removeViewElement(viewElement: ViewElement): void;
-
-  removeViewElement(options: string | ViewElement) {
-    let viewElement: ViewElement;
-    if (typeof options === 'string') {
-      viewElement = (this.elements as ViewElement[]).find((item) => item.name === options);
-      if (!viewElement) {
-        throw new Error('找不到页面元素 ' + options);
-      }
-    } else {
-      viewElement = options;
-    }
-    return viewElement.delete();
-  }
-
-  __removeViewElement(viewElement: ViewElement) {
-    const parentKey = viewElement.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: viewElement,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = viewElement.__v_raw || viewElement;
-      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;
-  }
-
-  //================================================================================
-  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-  // 自动生成的代码已结束。下面可以手动编写。
-  //================================================================================
-  static getDefaultOptions() {
-    return {
-      title: '业务组件',
-    };
-  }
-
-  getNamespace(): string {
-    if (this.parentNode && (this.parentNode as FrontendType).getNamespace) {
-      const parentNamespace = (this.parentNode as FrontendType).getNamespace();
-      const parentName = this.parentNode.name;
-      const arr = [parentNamespace];
-      if (this.parentNode.concept !== 'App' && parentName) {
-        arr.push(parentName);
-      }
-      return `${arr.join('.')}.businessComponents`;
-    }
-    throw new Error('无法获取命名空间，请设置 parentNode！');
-  }
-
-  getTsNamespace() {
-    const parentNodeNamespace = this.getNamespace();
-    let tsCalleeNamespace = parentNodeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
-    tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
-    return tsCalleeNamespace;
-  }
-
-  /**
-   * 获取当前业务组件下所有elements上bindEvents下的logic
-   */
-  elementLogicRoot: any[] = [];
-
-  getElementLogicRoot() {
-    const Param = getConceptConstructor('Param');
-    const logics: Array<Logic> = [];
-    // 页面上的绑定的事件
-    this.bindEvents.forEach((bindEvent) => {
-      bindEvent.logics.forEach((logic) => {
-        // 键盘事件
-        if (['keydown', 'keyup'].includes(bindEvent.name)) {
-          logic.virtualParams = [
-            Param.from(
-              {
-                name: 'event',
-                typeAnnotation: null,
-              },
-              logic,
-              'virtualParams',
-            ),
-          ];
-        }
-        // 生命周期没有event
-        logics.push(logic);
-      });
-    });
-    this.elements.forEach((item) => {
-      utils.traverse(
-        (current) => {
-          current.node.bindEvents.forEach((bindEvent) => {
-            bindEvent.logics.forEach((logic) => {
-              if (logic.name.startsWith('__')) {
-                return;
-              }
-              // 绑定参数才有 event 的 current
-              logic.virtualParams = bindEvent.getContextRenderLogicParams(logic);
-              logics.push(logic);
-            });
-          });
-        },
-        { node: item },
-      );
-    });
-    if (logics.length) {
-      const expanded = (this.elementLogicRoot.length && this.elementLogicRoot[0].expanded) || false;
-      this.elementLogicRoot = [
-        {
-          concept: 'elementLogicRoot',
-          expanded,
-          children: logics,
-        },
-      ];
-    } else {
-      this.elementLogicRoot = [];
-    }
-  }
-
-  getVarExistingNames(excludedList: Array<Param | Variable> = []) {
-    const excludedSet = new Set(excludedList);
-    const varList: any[] = [];
-    if (Array.isArray(this.params)) {
-      varList.push(...this.params);
-    }
-    if (Array.isArray(this.variables)) {
-      varList.push(...this.variables);
-    }
-    if (Array.isArray(this.logics)) {
-      this.logics.forEach((logic) => {
-        varList.push(logic);
-        if (Array.isArray(logic.params)) {
-          varList.push(...logic.params);
-        }
-        if (Array.isArray(logic.returns)) {
-          varList.push(...logic.returns);
-        }
-        if (Array.isArray(logic.variables)) {
-          varList.push(...logic.variables);
-        }
-      });
-    }
-    // 事件逻辑的变量不允许和页面逻辑下的重复
-    if (Array.isArray(this.elementLogicRoot) && this.elementLogicRoot.length) {
-      this.elementLogicRoot[0]?.children.forEach((logic: Logic) => {
-        if (Array.isArray(logic.variables)) {
-          varList.push(...logic.variables);
-        }
-      });
-    }
-    return varList.filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-
-  existingViewElement: Set<string> = new Set<string>();
-
-  // 收集已经存在的ViewElement
-  collectExistingViewElementName(excludedList: Array<ViewElement> = []) {
-    const excludedSet = new Set(excludedList);
-    this.elements.forEach((element) => {
-      utils.traverse(
-        ({ node }) => {
-          if (!excludedSet.has(node)) {
-            this.existingViewElement.add(node.name);
-          }
-        },
-        {
-          node: element,
-        },
-      );
-    });
-  }
-
-  // 获取当前业务组件的所有组件的名字
-  getViewElementExistingNames(excludedList: Array<ViewElement> = []) {
-    if (!this.existingViewElement.size) {
-      this.collectExistingViewElementName();
-    }
-    return Array.from(this.existingViewElement);
-  }
-
-  getViewElementUniqueNameOld(name = 'viewElement1') {
-    this.collectExistingViewElementName();
-    const viewElementUniqueName = utils.unique(name, this.existingViewElement);
-    this.existingViewElement.add(viewElementUniqueName);
-    return viewElementUniqueName;
-  }
-
-  getViewElementUniqueName(name = 'viewElement_1') {
-    this.collectExistingViewElementName();
-    const BranchCopyUniCode = getBranchCopyUniCode();
-    let newName = name;
-    const prefix = name.replace(/\d*$/, '');
-    if (BranchCopyUniCode && prefix.indexOf(`_${BranchCopyUniCode}_`) === -1) {
-      newName = name.replace(/\d*$/, (m) => `_${BranchCopyUniCode}_${m}`);
-    }
-    // 主分支无 BranchCopyUniCode
-    if (!BranchCopyUniCode && prefix.at(-1) !== '_') {
-      newName = name.replace(/\d*$/, (m) => `_${m}`);
-    }
-    const newPrefix = newName.replace(/\d*$/, '');
-    const newPrefixNum = removedViewElementCache?.[newPrefix] ? removedViewElementCache[newPrefix] : 1;
-    const startNum =
-      newPrefixNum < Number.MAX_SAFE_INTEGER ? (newPrefixNum as number) + 1 : BigInt(newPrefixNum) + BigInt(1);
-    const viewElementUniqueName = utils.uniqueMax(
-      newName,
-      this.existingViewElement,
-      removedViewElementCache?.[newPrefix] ? startNum : newPrefixNum,
-    );
-    this.existingViewElement.add(viewElementUniqueName);
-    return viewElementUniqueName;
-  }
-
-  // 获取当前element，铺平
-  elementsMethods(elements: Array<ViewElement>, allMethods: Array<ViewElement>, parentNodeNames: Array<string>) {
-    if (elements) {
-      elements.forEach((item: ViewElement) => {
-        const { bindAttrs = [], name } = item;
-        const isDataSource = bindAttrs.some((attr) => attr.name === 'data-source');
-        const isInclude = parentNodeNames.includes(name);
-
-        allMethods.push(item);
-        if (item.children) {
-          if (isDataSource) {
-            if (isInclude) {
-              this.elementsMethods(item.children, allMethods, parentNodeNames);
-            }
-          } else {
-            this.elementsMethods(item.children, allMethods, parentNodeNames);
-          }
-        }
-      });
-    }
-  }
-
-  mergeBlock({ code, nodePath, position, cb }: { code: string; nodePath: string; position: string; cb?: Function }) {
-    const ViewElement = getConceptConstructor('ViewElement');
-    const Logic = getConceptConstructor('Logic');
-    const ParamWithGroup = getConceptConstructor('ParamWithGroup');
-    const Variable = getConceptConstructor('Variable');
-    const BindEvent = getConceptConstructor('BindEvent');
-    const Structure = getConceptConstructor('Structure');
-    const template = utils.sliceTagContent(code, 'template');
-    let targetNode = (this.getAncestor('App') as App)?.findNodeByPath(nodePath);
-    let parentNode = position === 'append' ? targetNode : targetNode.parentNode;
-    const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
-    const definition: any = JSON.parse(definitionStr);
-    let node = null;
-    if (template) {
-      node = ViewElement.fromHTML(template, {
-        view: this,
-        definition,
-      });
-      if (!parentNode) {
-        return;
-      }
-      if (position === 'append') {
-        parentNode.addViewElement(node);
-        cb && cb(parentNode, node);
-      } else {
-        const index = targetNode.getIndexOfParent();
-        if (position === 'insertBefore') {
-          parentNode.insertViewElementAt(node, index);
-        } else if (position === 'insertAfter') {
-          parentNode.insertViewElementAt(node, index + 1);
-        }
-      }
-    }
-
-    // 服务端逻辑
-    if (Array.isArray(definition.logics)) {
-      definition.logics.forEach((logicOption: any) => {
-        const logic = Logic.from(
-          {
-            ...logicOption,
-          },
-          this.rootNode,
-          'logics',
-        );
-        (this.rootNode as App).addLogic(logic);
-      });
-    }
-
-    // 全局结构体
-    if (Array.isArray(definition.structures)) {
-      definition.structures.forEach((structureOption: any) => {
-        const structure = Structure.from(
-          {
-            ...structureOption,
-          },
-          this.rootNode,
-          'structures',
-        );
-        (this.rootNode as App).addStructure(structure);
-      });
-    }
-
-    // 页面入参
-    if (Array.isArray(definition.viewParams)) {
-      definition.viewParams.forEach((paramsOption: any) => {
-        const param = ParamWithGroup.from(
-          {
-            ...paramsOption,
-          },
-          this,
-          'params',
-        );
-        this._addParam(param);
-        param.addParamsPrepare();
-      });
-    }
-    // 页面变量
-    if (Array.isArray(definition.viewVariables)) {
-      definition.viewVariables.forEach((variableOption: any) => {
-        const variable = Variable.from(
-          {
-            ...variableOption,
-          },
-          this,
-          'variables',
-        );
-        this.addVariable(variable);
-      });
-    }
-
-    // 页面事件
-    if (Array.isArray(definition.viewBindEvents)) {
-      definition.viewBindEvents.forEach((eventOption: any) => {
-        const newLogic = definition.viewLogics.find((logic: Logic) => eventOption.calleeName === logic.name);
-        const bindEvent = this.bindEvents.find((currentEventItem) => currentEventItem.name === eventOption.name);
-
-        // 如果没有event对象就先新增一个，如果已经有了就在内部添加logic
-        if (!bindEvent) {
-          const event = BindEvent.from(
-            {
-              ...eventOption,
-              calleeName: '',
-              logics: [newLogic],
-            },
-            this,
-            'events',
-          );
-          this.addBindEvent(event);
-        } else {
-          bindEvent.addLogic(newLogic);
-        }
-      });
-    }
-    return node;
-  }
-
-  onChange($event?: EventPayload): void {
-    this.emit('change', $event);
-  }
-
-  /**
-   * 转换成设计器中使用的 Vue template 内容
-   * @param options
-   */
-  genDesignerVueTemplate(options?: { asCompontent?: boolean }) {
-    return this.elements
-      .map(
-        (element) =>
-          `${element.toDesignerVue({
-            isRoot: true,
-            asCompontent: options?.asCompontent,
-          })}\n`,
-      )
-      .join('');
-  }
-
-  get frontendType() {
-    return this.getAncestor('FrontendType') as FrontendType;
-  }
-
-  get path() {
-    return `/${this.frontendType?.kind}/${this.name}`;
-  }
-
-  get slotElems() {
-    const slotElems: ViewElement[] = [];
-    this.elements.forEach((element) => {
-      utils.traverse(
-        ({ node }) => {
-          if (node.tag === 'slot') {
-            slotElems.push(node);
-          }
-        },
-        {
-          node: element,
-        },
-      );
-    });
-    return slotElems;
-  }
-
-  /**
-   * 转换成 Vue 文件
-   */
-  toVue(options?: ElementToVueOptions) {
-    let result = '';
-    result += `<template>\n${this.genVueTemplate(options)}\n</template>\n`;
-    result += `<script>\n${this.genScript()}\n</script>\n`;
-    return result;
-  }
-
-  /**
-   * 生成宿主语言的文件路径
-   * @param name 一般不用传，用于 rename
-   */
-  getEmbeddedFilePath(name = this.name) {
-    return `/embedded/${this.rootNode?.name || this.parentNode.name}/frontendTypes/${this.getAncestor('FrontendType')?.name
-      }/${name}.ts`;
-  }
-
-  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
-    let code = `namespace ${this.getTsNamespace()} {\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,
-    };
-  }
-
-  getAncestorViewElementsWithDataSource(logic: Logic): ViewElement[] {
-    let element: types.SyntaxNode = logic;
-    const viewElements: ViewElement[] = [];
-    while (element) {
-      if (
-        element.concept &&
-        element.concept === 'ViewElement' &&
-        (element as ViewElement).bindAttrs.find((bAttr) => bAttr.name === 'data-source')
-      ) {
-        viewElements.push(element as ViewElement);
-      }
-      element = element.parentNode;
-    }
-    return viewElements;
-  }
-
-  *handleCurrentItemCode(code: string, logic: Logic) {
-    const viewElementsWithDataSource: ViewElement[] = this.getAncestorViewElementsWithDataSource(logic);
-    yield* wrapForEach(viewElementsWithDataSource, function* wrapForEach(viewElement, index) {
-      const currentIndex = viewElementsWithDataSource.length - 1 - index;
-      const currentItemCode = `current${currentIndex === 0 ? '' : currentIndex}.item`;
-      if (code.includes(currentItemCode)) {
-        const dataSource = viewElement.bindAttrs.find((bAttr) => bAttr.name === 'data-source');
-        if (dataSource) {
-          const businessComponent = viewElement.getAncestor('BusinessComponent') as BusinessComponent;
-          const dataSourceTS = yield* dataSource.expression.toEmbeddedTS();
-          const logic = businessComponent.logics.find((logic) => logic.name === dataSourceTS);
-          if (logic) {
-            code = code.replaceAll(
-              currentItemCode,
-              `nasl.ui.getCurrentItemType(${dataSourceTS}(${logic.params.map(() => 'null').join(',')}))`,
-            );
-          } else {
-            const variable = businessComponent.variables.find((variable) => variable.name === dataSourceTS);
-            code = code.replaceAll(
-              currentItemCode,
-              `nasl.ui.getCurrentItemType(${variable ? variable.name : dataSourceTS})`,
-            );
-          }
-        }
-      }
-    });
-    return code;
-  }
-
-  removeExistingViewElement(viewElement: ViewElement) {
-    if (this.existingViewElement.has(viewElement.name)) {
-      this.existingViewElement.delete(viewElement.name);
-    }
-
-    const prefix = viewElement?.name.replace(/\d*$/, '');
-    let lastDigit = viewElement?.name.match(/\d+$/)?.[0];
-    if (lastDigit === undefined) return;
-
-    //@ts-ignore
-    lastDigit = lastDigit < Number.MAX_SAFE_INTEGER ? parseInt(lastDigit) : BigInt(lastDigit);
-
-    if (removedViewElementCache?.[prefix]) {
-      //@ts-ignore
-      if (lastDigit > removedViewElementCache[prefix])
-        //@ts-ignore
-        removedViewElementCache[prefix] = lastDigit;
-    } else {
-      //@ts-ignore
-      removedViewElementCache[prefix] = lastDigit;
-    }
-  }
-
-  *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
-    code = code.replaceAll('\n', ' ');
-    const logic = assignment.logic;
-    const logicRtn = logic?.returns[0];
-    // 调用接口，参数替换成 null
-    if (asserts.isCallInterface(rightNode)) {
-      const { _interface } = rightNode.getModuleInterface();
-      return _interface
-        ? `${rightNode.tsCalleeKey}(${(_interface as Interface).params.map(() => 'null').join(',')})`
-        : null;
-    }
-
-    // 调用服务端逻辑，参数替换成 null
-    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
-      const calleeName = rightNode?.calleeName;
-      const calleeLogic = (this.getAncestor('App') as App).logics.find((l) => l.name === calleeName);
-      return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
-    }
-
-    // view 局部变量，申明提升前增加判断，使用 logic 内的 result 直接替换成对应 logic，logic 内部变量替换成 null
-    if (logicRtn && code.includes(logicRtn.name)) {
-      if (code === logicRtn.name) return `${logic.name}(${logic.params.map(() => 'null').join(',')})`;
-
-      code = this.handleReplaceCode(code, logicRtn.name, `${logic.name}(${logic.params.map(() => 'null').join(',')})`);
-      logic.params.forEach((param) => {
-        if (code.includes(param.name)) code = this.handleReplaceCode(code, param.name, 'null');
-      });
-      logic.variables.forEach((variable) => {
-        if (code.includes(variable.name)) code = this.handleReplaceCode(code, variable.name, 'null');
-      });
-      return code;
-    }
-
-    // 处理 current.item、current1.item 等数据
-    if (/current(\d)*\.item/.test(code)) {
-      code = yield* this.handleCurrentItemCode(code, logic);
-      return code;
-    }
-
-    // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
-    const useLogicVar =
-      logic.params.find((param) => code.includes(param.name)) ||
-      logic.variables.find((variable) => code.includes(variable.name));
-    return useLogicVar ? 'null' : code;
-  }
-
-  handleReplaceCode(code: string, variable: string, replaceCode: string) {
-    return code.replace(/\S+/g, ($1) => {
-      if ($1 === `${variable},`) return `${replaceCode},`;
-      if ($1 === variable) return replaceCode;
-
-      let fnCode = $1;
-      if ($1.startsWith(`${variable}.`)) fnCode = $1.replaceAll(`${variable}.`, `${replaceCode}.`);
-      if ($1.startsWith(`${variable},`)) fnCode = $1.replaceAll(`${variable},`, `${replaceCode},`);
-      if ($1.includes(`(${variable},`)) fnCode = $1.replaceAll(`(${variable},`, `(${replaceCode},`);
-      if ($1.includes(`(${variable}.`)) fnCode = $1.replaceAll(`(${variable}.`, `(${replaceCode}.`);
-      if ($1.includes(`(${variable})`)) fnCode = $1.replaceAll(`(${variable})`, `(${replaceCode})`);
-      if ($1.includes(`,${variable},`)) fnCode = $1.replaceAll(`,${variable},`, `,${replaceCode},`);
-      if ($1.includes(`,${variable}.`)) fnCode = $1.replaceAll(`,${variable}.`, `,${replaceCode}.`);
-      if ($1.includes(`,${variable})`)) fnCode = $1.replaceAll(`,${variable})`, `,${replaceCode})`);
-      return fnCode;
-    });
-  }
-
-  // 获取当前element，铺平
-  elementsAttrs(elements: Array<ViewElement>, componentList: Array<ViewElement>) {
-    if (elements) {
-      elements.forEach((item: ViewElement) => {
-        if (PAGE_COMPONENT_INCLUDE_TAG_MAP?.[item.tag]) {
-          componentList.push(item);
-        }
-        if (item.children.length > 0) {
-          this.elementsAttrs(item.children, componentList);
-        }
-      });
-    }
-  }
-
-  elementsAttrsAll(elements: Array<ViewElement>, componentListExtra: Array<ViewElement>) {
-    if (elements) {
-      elements.forEach((item: ViewElement) => {
-        if (!PAGE_COMPONENT_INCLUDE_TAG_MAP?.[item.tag]) {
-          componentListExtra.push(item);
-        }
-        if (item.children.length > 0) {
-          this.elementsAttrsAll(item.children, componentListExtra);
-        }
-      });
-    }
-  }
-
-  @withSourceMapGenerator
-  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
-    const self = this;
-    // 获取虚拟logic的参数和内容
-    // 用作展示和tots查找引用
-    self.getElementLogicRoot();
-    let code = `export class ${self.tsName} extends nasl.ui.VueComponent {\n`;
-    // 需要类型推导的局部变量/返回值需要调整申明顺序
-    code += `constructor(
-      options?: {
-        [propname: string]: any,
-        bindAttr?: {
-          __NASLIF?: nasl.core.Boolean,
-    `;
-    if (Array.isArray(self.params)) {
-      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
-        code += `${param.name}?: `;
-        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
-        code += ',\n';
-      });
-    }
-    code += `
-        },
-        slotDefault?: () => Array<any>,
-      }) {
-        super();\n`;
-
-    // 绑定事件
-    if (Array.isArray(self.bindEvents)) {
-      yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(event) {
-        code += yield* event.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: state?.tabSize || 0,
-          }),
-          true,
-        );
-        code += '\n';
-      });
-    }
-    code += `\n}`;
-    // 自定义事件的定义
-    if (Array.isArray(self.events) && self.events.length) {
-      code += indent((state?.tabSize || 0) + 1);
-      yield* wrapForEach(self.events, function* warpForEachGenerator(event) {
-        code += yield* event.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 2,
-          }),
-        );
-        code += '\n';
-      });
-      code += indent((state?.tabSize || 0) + 1);
-    }
-    // 逻辑
-    if (Array.isArray(self.logics) && self.logics.length) {
-      code += indent((state?.tabSize || 0) + 1);
-      yield* wrapForEach(self.logics, function* warpForEachGenerator(logic) {
-        code += yield* logic.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 2,
-          }),
-          'noExport',
-        );
-        code += '\n';
-      });
-      code += indent((state?.tabSize || 0) + 1);
-    }
-    // render函数
-    code += `\n${indent((state?.tabSize || 0) + 1)}`;
-    code += `__render(`;
-    code += `){\n`;
-    code += indent(state?.tabSize || 0);
-    // elements 元素
-    if (Array.isArray(self.elements)) {
-      // 生成嵌套式的内容
-      yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
-        code += yield* element.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 3,
-          }),
-        );
-        code += '\n';
-      });
-    }
-    code += `\n${indent((state?.tabSize || 0) + 1)}}\n`;
-    if (Array.isArray(self.params)) {
-      code += `${indent((state?.tabSize || 0) + 1)}$destination(options: {`;
-      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
-        code += `${param.name}?: `;
-        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
-        code += ', ';
-      });
-      // 锚点
-      code += `_anchor?: nasl.core.String`;
-      code += '}){}\n';
-    }
-    code += `${indent(state?.tabSize || 0)}}\n`;
-
-    // elements类型声明定义
-    code += `interface __elements {\n`;
-    // 生成所有的name和类型定义
-    yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
-      code += yield* element.toEmbeddedTSDefinition(
-        shiftState(state, code, {
-          tabSize: (state?.tabSize || 0) + 1,
-        }),
-      );
-    });
-    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
-    code += `let __elements: __elements;\n`;
-
-    if (Array.isArray(self.elements)) {
-      code += `${indent((state?.tabSize || 0) + 1)}interface `;
-      code += `__elements_completionProperty {\n`;
-      const componentList: Array<ViewElement> = [];
-      self.elementsAttrs(self.elements, componentList);
-      const variableList: string[] = [];
-      yield* wrapForEach(self.elements, function* warpForEachGenerator(item) {
-        code += yield* item.toEmbeddedTSVariableDefinition(shiftState(state, code, { inline: true }), variableList);
-      });
-      code += indent((state?.tabSize || 0) + 1) + `}\n`;
-      code += indent((state?.tabSize || 0) + 1);
-      code += `let __elements_completionProperty: __elements_completionProperty;\n`;
-      code += indent((state?.tabSize || 0) + 1);
-      code += `let __elements_variable_function = {\n`;
-      yield* wrapForEach(self.elements, function* warpForEachGenerator(item) {
-        code += yield* item.toEmbeddedTSVariableFunctionDefinition(shiftState(state, code, { inline: true }));
-      });
-      code += indent((state?.tabSize || 0) + 1) + `}\n`;
-      code += indent((state?.tabSize || 0) + 1);
-      code += `let __elements_stashFunctionVariable = {\n`;
-      yield* wrapForEach(variableList, function* warpForEachGenerator(item) {
-        code += indent((state?.tabSize || 0) + 2);
-        code += `${item}`;
-      });
-      code += indent((state?.tabSize || 0) + 1) + `}\n`;
-    }
-
-    const advanceMap: Map<Variable, Assignment | BatchAssignment> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                returnOrigin('')
-                : yield* el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-          });
-        }
-      }
-    });
-
-    // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
-    const IDENTIFIERMAP = new Set<Variable>();
-    if (Array.isArray(self.params)) {
-      yield* wrapForEach(self.params, function* warpForEachGenerator(param) {
-        code += `let ${indent((state?.tabSize || 0) + 1)}`;
-        code += yield* param.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        code += ';\n';
-      });
-    }
-    if (Array.isArray(self.variables)) {
-      yield* wrapForEach(self.variables, function* warpForEachGenerator(variable) {
-        const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
-        if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
-          IDENTIFIERMAP.add(variable);
-        }
-        if (!advanceMap.get(variable)) {
-          code += `let ${indent((state?.tabSize || 0) + 1)}`;
-          code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
-          code += ';\n';
-        }
-      });
-    }
-    yield* wrapIterator(advanceMap.entries(), function* warpForEachGenerator([variable, assignment]) {
-      // 有默认值的用默认值来推导类型, 但是如果是__IDENTIFIER__或者__IDENTIFIER__()，就不需要默认值来推导了
-      if (variable.defaultValue?.expression && !IDENTIFIERMAP.has(variable)) {
-        code += `let ${indent((state?.tabSize || 0) + 1)}`;
-        code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        return;
-      }
-      code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
-      code += `let ${indent((state?.tabSize || 0) + 1)}`;
-      code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      code += ' = ';
-      if (asserts.isBatchAssignment(assignment)) {
-        yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
-          const leftCode =
-            leftIndex.length === 1
-              ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-              returnOrigin('');
-          if (leftCode === variable.name) {
-            const rightNode =
-              rightIndex.length === 1
-                ? assignment.rights[rightIndex[0]]?.expression
-                : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
-            const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-              returnOrigin('');
-            code += yield* self.getRightCode(rightCode, assignment, rightNode);
-          }
-        });
-      } else {
-        let rightCode = '';
-        // 因为右侧枚举要赋值就得new 一下；
-        if (
-          assignment.right &&
-          asserts.isIdentifier(assignment.right) &&
-          assignment.right.namespace &&
-          assignment.right.namespace.endsWith('enums')
-        ) {
-          rightCode += 'new ';
-        }
-        rightCode +=
-          assignment.right && assignment.right.toEmbeddedTS
-            ? yield* assignment.right.toEmbeddedTS(shiftState(state, code, { inline: true }))
-            : '__RIGHT__';
-        code += yield* self.getRightCode(rightCode, assignment, assignment.right);
-      }
-      code += ';\n';
-    });
-
-    /* 默认值草稿区 ---------------------------*/
-    code += `${indent((state?.tabSize || 0) + 1)}function __playground(){\n`;
-
-    /* 参数的默认值是__IDENTIFIER__或者__IDENTIFIER__()时不赋默认值，但是需要ts翻译出来进行报错校验 */
-    for (const node of IDENTIFIERMAP.values()) {
-      code += `${indent((state?.tabSize || 0) + 2)}`;
-      code += yield* node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      code += '; ';
-    }
-
-    code += '\n';
-    code += `${indent((state?.tabSize || 0) + 2)}return\n`;
-
-    function* setPlaygroundCode(arr: Variable[] | ParamWithGroup[], name: string) {
-      if (arr.length) {
-        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
-      }
-
-      for (const item1 of arr) {
-        for (const item of item1.defaultValue?.playground ?? []) {
-          code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-          code += ';\n';
-        }
-      }
-    }
-    yield* setPlaygroundCode(self.variables, 'variables');
-    yield* setPlaygroundCode(self.params, 'params');
-
-    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
-    return code;
-  }
-
-  /**
-   * 转换成 VueOptions
-   * @TODO 后面 template 可以优化成 render 函数
-   */
-  toVueOptions(options?: ElementToVueOptions) {
-    return {
-      template: this.genVueTemplate(options),
-      script: this.genScript(),
-    };
-  }
-
-  genVueTemplate(options?: ElementToVueOptions) {
-    return this.elements?.map((element) => `${element?.toVue(options)}\n`).join('');
-  }
-
-  getViewBindEvents() {
-    const bindEvents: Array<BindEvent> = [];
-    // 页面上的绑定的事件
-    this.bindEvents.forEach((bindEvent) => {
-      bindEvents.push(bindEvent);
-    });
-    this.elements.forEach((item) => {
-      utils.traverse(
-        (current) => {
-          current.node.bindEvents.forEach((bindEvent) => {
-            bindEvents.push(bindEvent);
-          });
-        },
-        { node: item },
-      );
-    });
-    return bindEvents;
-  }
-
-  // 获取页面上需要替换的表达式
-  getViewExpressions() {
-    const bindExpressions: any[] = [];
-    this.elements.forEach((item) => {
-      utils.traverse(
-        (current) => {
-          const { node } = current as any;
-          const playgroundNodePath = (node?.nodePath || '').split('.').find((nodePathNode: string) => {
-            return nodePathNode.match(/(.+)\[.+\]/)?.[1] === 'playground';
-          });
-          if (!playgroundNodePath) {
-            //// 处理三种情况
-            //if (
-            //    ['BindAttribute', 'BindDirective', 'BindStyle'].includes(node.concept)
-            //    && node.needReplaceWithIdentifier
-            //) {
-            //    bindExpressions.push(node);
-            //}
-            if (node?.concept === 'Match') {
-              bindExpressions.push(node as Match);
-            }
-          }
-        },
-        {
-          node: item,
-        },
-        {
-          mode: 'anyObject',
-          depthFirst: true,
-          excludedKeySet: new Set([
-            'bindEvents',
-            'parentNode',
-            'sourceMap',
-            'storageJSON',
-            'tsErrorDetail',
-            'NaslAnnotatedJSON',
-            'calledFrom',
-            '_events',
-            '_collectingList',
-            '_historyList',
-          ]),
-        },
-      );
-    });
-    return bindExpressions;
-  }
-
-  /**
-   * 生成 Vue 中需要的 JS 代码
-   * @TODO 这一版先做成 componentOptions 式的，后面再美化
-   */
-  genScript() {
-    const componentList: Array<ViewElement> = [];
-    const componentListExtra: Array<ViewElement> = [];
-    this.elementsAttrs(this.elements, componentList);
-    this.elementsAttrsAll(this.elements, componentListExtra);
-    const definition = {
-      params: this.params,
-      variables: this.variables,
-      logics: this.logics,
-      events: this.bindEvents,
-      title: this.title,
-      viewBindEvents: this.getViewBindEvents(),
-      viewExpressions: this.getViewExpressions(),
-      elements: componentList,
-      elementsAll: componentListExtra,
-    };
-    let code = '';
-    const keyboardEventMixinCode = `const keyboardEventMixin = {
-            mounted() {
-                document.addEventListener('keydown', this.onKeyDown);
-                document.addEventListener('keyup', this.onKeyUp);
-            },
-            beforeDestory() {
-                document.removeEventListener('keydown', this.onKeyDown);
-                document.removeEventListener('keyup', this.onKeyUp);
-            },
-            methods: {
-                async onKeyDown(e) {
-                    ${this.bindEvents
-        .filter((event) => ['keydown'].includes(event.name))
-        .map((event) => `await this.${event.view.name}_${event.name}(e);`)
-        .join('\n')}
-                },
-                async onKeyUp(e) {
-                    ${this.bindEvents
-        .filter((event) => ['keyup'].includes(event.name))
-        .map((event) => `await this.${event.view.name}_${event.name}(e);`)
-        .join('\n')}
-                }
-            }
-        };\n`;
-    code += keyboardEventMixinCode;
-    code += 'export default {\n';
-    code += 'mixins: [';
-    const mixins = [];
-    // 键盘事件mixin
-    mixins.push('keyboardEventMixin');
-    code += mixins.join(',');
-    code += '],';
-    code += translator(definition, this);
-    code += '};\n';
-    return code;
-  }
-
-  // 生成预览的模板
-  genPreviewTemplate() {
-    return `<template>
-              <bs-${this.name}>
-                ${this.slotElems.map((slotElem) => {
-      const slotName = slotElem.name;
-      return `<template #${slotName}></template>`;
-    }).join('')}
-              </bs-${this.name}>
-            </template>`;
-  }
-
-  //================================================================================
-  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //================================================================================
-}
-
-export default BusinessComponent;
-//================================================================================
-// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-// 自动生成的代码已结束。下面可以手动编写。
-//================================================================================