@lcap/nasl 0.3.15-beta → 1.0.0-alpha.2

package/src/concepts/View__.ts

@@ -0,0 +1,1850 @@
+import Namespace from './Namespace__';
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import translator from '../bak/translator';
+import Role from './Role__';
+import { ElementToVueOptions } from './ViewElement__';
+import { Structure } from './Structure__';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import ViewElement from './ViewElement__';
+import Param from './Param__';
+import Variable from './Variable__';
+import BindEvent from './BindEvent__';
+import Logic from './Logic__';
+import Module from './Module__';
+import App from './App__';
+
+/**
+ * 页面
+ */
+@concept
+export class View extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'View' = 'View';
+
+    /**
+     * 页面模板 Id
+     */
+    @property()
+    pageTemplateId: string = undefined;
+
+    /**
+     * 页面名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 前后端路径
+     */
+    @property()
+    tempPath: string = undefined;
+
+    /**
+     * 页面标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 面包屑
+     */
+    @property()
+    crumb: string = undefined;
+
+    /**
+     * 权限控制
+     */
+    @property()
+    auth: boolean = undefined;
+
+    /**
+     * 是否是默认跳转的页面
+     */
+    @property()
+    isIndex: boolean = undefined;
+
+    /**
+     * 未解析的模板代码
+     */
+    @property()
+    template: string = undefined;
+
+    /**
+     * 未解析的逻辑代码
+     */
+    @property()
+    script: string = undefined;
+
+    /**
+     * 未解析的样式代码
+     */
+    @property()
+    style: string = undefined;
+
+    /**
+     * 页面元素列表
+     */
+    @property('ViewElement')
+    elements: Array<ViewElement> = [];
+
+    /**
+     * 输入参数列表
+     */
+    @property('Param')
+    params: Array<Param> = [];
+
+    /**
+     * 局部变量列表
+     */
+    @property('Variable')
+    variables: Array<Variable> = [];
+
+    /**
+     * 元素绑定事件列表
+     */
+    @property('BindEvent')
+    events: Array<BindEvent> = [];
+
+    /**
+     * 逻辑列表
+     */
+    @property('Logic')
+    logics: Array<Logic> = [];
+
+    /**
+     * 绑定的角色
+     */
+    @property()
+    bindRoles: Array<string> = [];
+
+    /**
+     * 页面列表
+     */
+    @property('View')
+    children: Array<View> = [];
+
+    /**
+     * 祖先 Module
+     */
+    get module() {
+        return this.getAncestor('Module') as Module;
+    }
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<View>) {
+        source = Object.assign({}, View.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): View {
+        return super.from(source, parentNode, parentKey) as View;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeView?.(this);
+        }
+        return params;
+    }
+    /**
+     * 设置页面名称
+     */
+    setName(name: string) {
+        const object = {
+            name,
+        };
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
+
+    /**
+     * 设置页面标题
+     */
+    setTitle(title: string) {
+        const object = {
+            title,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置面包屑
+     */
+    setCrumb(crumb: string) {
+        const object = {
+            crumb,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置权限控制
+     */
+    setAuth(auth: boolean) {
+        const object = {
+            auth,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置是否是默认跳转的页面
+     */
+    setIsIndex(isIndex: boolean) {
+        const object = {
+            isIndex,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    
+
+    /**
+    * 插入页面元素
+    * @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' };
+        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 (options instanceof ViewElement) {
+            options.delete(); // 同一实例不支持多处存在
+            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.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'elements',
+        });
+        return node;
+    }
+
+
+    getParamExistingNames(excludedList: Array<Param> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.params.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getParamUniqueName(name = 'param1') {
+        return utils.unique(name, this.getParamExistingNames());
+    }
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertParamAt(name: string, index: number): Param;
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param paramOptions 输入参数参数
+    */
+    _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param param 已有的输入参数实例
+    */
+    _insertParamAt(param: Param, index: number): Param;
+
+    _insertParamAt(options: string | Partial<Param> | Param, index: number) {
+        const paramOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'params' };
+        let param: Param;
+        if (!options) {
+            param = Param.from({
+                ...paramOptions,
+                name: this.getParamUniqueName(),
+            }, this, 'params');
+        } else if (typeof options === 'string') {
+            param = Param.from({
+                ...paramOptions,
+                name: options,
+            }, this, 'params');
+        } else if (options instanceof Param) {
+            options.delete(); // 同一实例不支持多处存在
+            param = options;
+            Object.assign(param, relationOptions);
+        } else {
+            param = Param.from({
+                ...paramOptions,
+                ...options,
+            }, this, 'params');
+        }
+        this.params.splice(index, 0, param);
+        return param;
+    }
+
+    /**
+     * 插入输入参数
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertParamAt(name: string, index: number): Param;
+
+    /**
+     * 插入输入参数
+     * @param paramOptions 输入参数参数
+     */
+    insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+    /**
+     * 插入输入参数
+     * @param param 已有的输入参数实例
+     */
+    insertParamAt(param: Param, index: number): Param;
+
+    insertParamAt(options: string | Partial<Param> | Param, 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): Param;
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _addParam(paramOptions: Partial<Param>): Param;
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _addParam(param: Param): Param;
+
+    _addParam(options?: string | Partial<Param> | Param) {
+        const index = this.params.length;
+        return this._insertParamAt(options as any, index);
+    }
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    addParam(name?: string): Param;
+
+    /**
+     * 添加输入参数
+     * @param paramOptions 输入参数参数
+     */
+    addParam(paramOptions: Partial<Param>): Param;
+
+    /**
+     * 添加输入参数
+     * @param param 已有的输入参数实例
+     */
+    addParam(param: Param): Param;
+
+    addParam(options?: string | Partial<Param> | Param) {
+        const node = this._addParam(options as any);
+        const index = this.params.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'params',
+        });
+        return node;
+    }
+
+
+    getVariableExistingNames(excludedList: Array<Variable> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.variables.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getVariableUniqueName(name = 'variable1') {
+        return utils.unique(name, this.getVariableExistingNames());
+    }
+
+    /**
+    * 插入局部变量
+    * @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' };
+        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 (options instanceof Variable) {
+            options.delete(); // 同一实例不支持多处存在
+            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.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+
+    getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.events.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getBindEventUniqueName(name = 'bindEvent1') {
+        return utils.unique(name, this.getBindEventExistingNames());
+    }
+
+    /**
+    * 插入元素绑定事件
+    * @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: 'events' };
+        let bindEvent: BindEvent;
+        if (!options) {
+            bindEvent = BindEvent.from({
+                ...bindEventOptions,
+                name: this.getBindEventUniqueName(),
+            }, this, 'events');
+        } else if (typeof options === 'string') {
+            bindEvent = BindEvent.from({
+                ...bindEventOptions,
+                name: options,
+            }, this, 'events');
+        } else if (options instanceof BindEvent) {
+            options.delete(); // 同一实例不支持多处存在
+            bindEvent = options;
+            Object.assign(bindEvent, relationOptions);
+        } else {
+            bindEvent = BindEvent.from({
+                ...bindEventOptions,
+                ...options,
+            }, this, 'events');
+        }
+        this.events.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: 'events',
+        });
+        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.events.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.events.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'events',
+        });
+        return node;
+    }
+
+
+    getLogicExistingNames(excludedList: Array<Logic> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.logics.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getLogicUniqueName(name = 'logic1') {
+        return utils.unique(name, this.getLogicExistingNames());
+    }
+
+    /**
+    * 插入逻辑
+    * @internal
+    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+    */
+    _insertLogicAt(name: string, index: number): Logic;
+
+    /**
+    * 插入逻辑
+    * @internal
+    * @param logicOptions 逻辑参数
+    */
+    _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+
+    /**
+    * 插入逻辑
+    * @internal
+    * @param logic 已有的逻辑实例
+    */
+    _insertLogicAt(logic: Logic, index: number): Logic;
+
+    _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+        const logicOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'logics' };
+        let logic: Logic;
+        if (!options) {
+            logic = Logic.from({
+                ...logicOptions,
+                name: this.getLogicUniqueName(),
+            }, this, 'logics');
+        } else if (typeof options === 'string') {
+            logic = Logic.from({
+                ...logicOptions,
+                name: options,
+            }, this, 'logics');
+        } else if (options instanceof Logic) {
+            options.delete(); // 同一实例不支持多处存在
+            logic = options;
+            Object.assign(logic, relationOptions);
+        } else {
+            logic = Logic.from({
+                ...logicOptions,
+                ...options,
+            }, this, 'logics');
+        }
+        this.logics.splice(index, 0, logic);
+        return logic;
+    }
+
+    /**
+     * 插入逻辑
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    insertLogicAt(name: string, index: number): Logic;
+
+    /**
+     * 插入逻辑
+     * @param logicOptions 逻辑参数
+     */
+    insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+
+    /**
+     * 插入逻辑
+     * @param logic 已有的逻辑实例
+     */
+    insertLogicAt(logic: Logic, index: number): Logic;
+
+    insertLogicAt(options: string | Partial<Logic> | Logic, 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): Logic;
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param logicOptions 逻辑参数
+     */
+    _addLogic(logicOptions: Partial<Logic>): Logic;
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param logic 已有的逻辑实例
+     */
+    _addLogic(logic: Logic): Logic;
+
+    _addLogic(options?: string | Partial<Logic> | Logic) {
+        const index = this.logics.length;
+        return this._insertLogicAt(options as any, index);
+    }
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    addLogic(name?: string): Logic;
+
+    /**
+     * 添加逻辑
+     * @param logicOptions 逻辑参数
+     */
+    addLogic(logicOptions: Partial<Logic>): Logic;
+
+    /**
+     * 添加逻辑
+     * @param logic 已有的逻辑实例
+     */
+    addLogic(logic: Logic): Logic;
+
+    addLogic(options?: string | Partial<Logic> | Logic) {
+        const node = this._addLogic(options as any);
+        const index = this.logics.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+
+
+
+
+    getViewExistingNames(excludedList: Array<View> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.children.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewUniqueName(name = 'view1') {
+        return utils.unique(name, this.getViewExistingNames());
+    }
+
+    /**
+    * 插入页面
+    * @internal
+    * @param name 页面名称，如果不填会自动生成一个唯一名称
+    */
+    _insertViewAt(name: string, index: number): View;
+
+    /**
+    * 插入页面
+    * @internal
+    * @param viewOptions 页面参数
+    */
+    _insertViewAt(viewOptions: Partial<View>, index: number): View;
+
+    /**
+    * 插入页面
+    * @internal
+    * @param view 已有的页面实例
+    */
+    _insertViewAt(view: View, index: number): View;
+
+    _insertViewAt(options: string | Partial<View> | View, index: number) {
+        const viewOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'children' };
+        let view: View;
+        if (!options) {
+            view = View.from({
+                ...viewOptions,
+                name: this.getViewUniqueName(),
+            }, this, 'children');
+        } else if (typeof options === 'string') {
+            view = View.from({
+                ...viewOptions,
+                name: options,
+            }, this, 'children');
+        } else if (options instanceof View) {
+            options.delete(); // 同一实例不支持多处存在
+            view = options;
+            Object.assign(view, relationOptions);
+        } else {
+            view = View.from({
+                ...viewOptions,
+                ...options,
+            }, this, 'children');
+        }
+        this.children.splice(index, 0, view);
+        return view;
+    }
+
+    /**
+     * 插入页面
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    insertViewAt(name: string, index: number): View;
+
+    /**
+     * 插入页面
+     * @param viewOptions 页面参数
+     */
+    insertViewAt(viewOptions: Partial<View>, index: number): View;
+
+    /**
+     * 插入页面
+     * @param view 已有的页面实例
+     */
+    insertViewAt(view: View, index: number): View;
+
+    insertViewAt(options: string | Partial<View> | View, index: number) {
+        const node = this._insertViewAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'children',
+        });
+        return node;
+    }
+
+    /**
+     * 添加页面
+     * @internal
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    _addView(name?: string): View;
+
+    /**
+     * 添加页面
+     * @internal
+     * @param viewOptions 页面参数
+     */
+    _addView(viewOptions: Partial<View>): View;
+
+    /**
+     * 添加页面
+     * @internal
+     * @param view 已有的页面实例
+     */
+    _addView(view: View): View;
+
+    _addView(options?: string | Partial<View> | View) {
+        const index = this.children.length;
+        return this._insertViewAt(options as any, index);
+    }
+
+    /**
+     * 添加页面
+     * @internal
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    addView(name?: string): View;
+
+    /**
+     * 添加页面
+     * @param viewOptions 页面参数
+     */
+    addView(viewOptions: Partial<View>): View;
+
+    /**
+     * 添加页面
+     * @param view 已有的页面实例
+     */
+    addView(view: View): View;
+
+    addView(options?: string | Partial<View> | View) {
+        const node = this._addView(options as any);
+        const index = this.children.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'children',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除页面元素
+    * @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.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;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(viewElement);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === viewElement) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除输入参数
+    * @param name 输入参数名称
+    */
+    removeParam(name: string): void;
+
+    /**
+     * 删除输入参数
+     * @param param 已有的输入参数实例
+     */
+    removeParam(param: Param): void;
+
+    removeParam(options: string | Param) {
+        let param: Param;
+        if (typeof options === 'string') {
+            param = this.params.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;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(param);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === param) {
+                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.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;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(variable);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === variable) {
+                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.events.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;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(bindEvent);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === bindEvent) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除逻辑
+    * @param name 逻辑名称
+    */
+    removeLogic(name: string): void;
+
+    /**
+     * 删除逻辑
+     * @param logic 已有的逻辑实例
+     */
+    removeLogic(logic: Logic): void;
+
+    removeLogic(options: string | Logic) {
+        let logic: Logic;
+        if (typeof options === 'string') {
+            logic = this.logics.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;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logic);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logic) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除页面
+    * @param name 页面名称
+    */
+    removeView(name: string): void;
+
+    /**
+     * 删除页面
+     * @param view 已有的页面实例
+     */
+    removeView(view: View): void;
+
+    removeView(options: string | View) {
+        let view: View;
+        if (typeof options === 'string') {
+            view = this.children.find((item) => item.name === options);
+            if (!view) {
+                throw new Error('找不到页面 ' + options);
+            }
+        } else {
+            view = options;
+        }
+        return view.delete();
+    }
+
+    __removeView(view: View) {
+        const parentKey = view.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: view,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(view);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === view) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    /**
+     * 设置页面权限
+     */
+    setBindRoles(bindRoles: string[]) {
+        const object = {
+            bindRoles,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    findLogicByName(name: string) {
+        return this.logics.find((logic) => logic.name === 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> = []) {
+        const excludedSet = new Set(excludedList);
+        return Array.from(this.existingViewElement);
+    }
+
+    getViewElementUniqueName(name = 'viewElement1') {
+        this.collectExistingViewElementName();
+        const viewElementUniqueName = utils.unique(name, this.existingViewElement);
+        this.existingViewElement.add(viewElementUniqueName);
+        return viewElementUniqueName;
+    }
+
+    // 组件名是否有效
+    isValidElementName(name: string): boolean {
+        if (name) {
+            return !this.getViewElementExistingNames().find((existingName) => existingName === name);
+        }
+        return false;
+    }
+
+    public static readonly TAG_NAME_PREFIX_REG?: RegExp = /^([lieu]|van)[-_]/;
+
+    mergeBlock({ code, nodePath, position }: { code: string; nodePath: string; position: string }) {
+        const template = utils.sliceTagContent(code, 'template');
+        let targetNode = this.app.findNodeByPath(nodePath);
+        let parentNode = position === 'append' ? targetNode : targetNode.parentNode;
+        if (parentNode.concept === 'View') {
+            parentNode = targetNode;
+            if (position === 'insertBefore') {
+                targetNode = parentNode.children[0];
+            } else if (position === 'insertAfter') {
+                const len = parentNode.children.length;
+                targetNode = parentNode.children[len - 1];
+            }
+        }
+        const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
+        const definition: any = JSON.parse(definitionStr);
+
+        if (template) {
+            const node = ViewElement.fromHTML(template, {
+                view: this,
+            });
+            if (!parentNode) {
+                return;
+            }
+            if (position === 'append') {
+                parentNode.addViewElement(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.structures)) {
+            definition.structures.forEach((structureOption: any) => {
+                const structure = Structure.from({
+                    ...structureOption,
+                }, this.rootNode, 'structures');
+                (this.rootNode as App).addStructure(structure);
+            });
+        }
+
+        // 全局逻辑
+        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.viewParams)) {
+            definition.viewParams.forEach((paramsOption: any) => {
+                const param = Param.from({
+                    ...paramsOption,
+                }, this, 'params');
+                this.addParam(param);
+            });
+        }
+        // 页面变量
+        if (Array.isArray(definition.viewVariables)) {
+            definition.viewVariables.forEach((variableOption: any) => {
+                const variable = Variable.from({
+                    ...variableOption,
+                }, this, 'variables');
+                this.addVariable(variable);
+            });
+        }
+
+        // 页面逻辑
+        if (Array.isArray(definition.viewLogics)) {
+            definition.viewLogics.forEach((logicOption: any) => {
+                const logic = Logic.from({
+                    ...logicOption,
+                }, this, 'logics');
+                this.addLogic(logic);
+            });
+        }
+
+        // 页面事件
+        if (Array.isArray(definition.viewBindEvents)) {
+            definition.viewBindEvents.forEach((eventOption: any) => {
+                const event = BindEvent.from({
+                    ...eventOption,
+                }, this, 'events');
+                this.addBindEvent(event);
+            });
+        }
+    }
+
+    onChange($event?: EventPayload): void {
+        this.emit('change', $event);
+    }
+
+    getVarExistingNames(excludedList: Array<Param | Variable> = []) {
+        const excludedSet = new Set(excludedList);
+        return [...this.params, ...this.variables].filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+
+    /**
+     * 角色
+     */
+    @property()
+    roles: Array<{
+        namespace: string;
+        name: string;
+    }> = [];
+
+    toggleRole(role: Role) {
+        const index = this.roles.findIndex((roleItem) => roleItem.name === role.name);
+        const roles = [...this.roles];
+        if (index !== -1) {
+            roles.splice(index, 1);
+            this.roles = roles;
+        } else {
+            roles.push({
+                namespace: role.getNamespace(),
+                name: role.name,
+            });
+        }
+        const object = {
+            roles,
+        };
+
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 生成 Vue 中需要的 JS 代码
+     * @TODO 这一版先做成 componentOptions 式的，后面再美化
+     */
+    genScript() {
+        let componentOptions = 'const componentOptions = {};';
+        if (this.script)
+            componentOptions = this.script.trim().replace(/export default |module\.exports +=/, 'const componentOptions = ');
+
+        const definition = {
+            params: this.params,
+            variables: this.variables,
+            logics: this.logics,
+            events: this.events,
+            title: this.title,
+            crumb: this.crumb,
+            first: this.isIndex,
+        };
+        return `${componentOptions}
+            ${translator(definition)}
+        export default componentOptions;
+`;
+    }
+    genVueTemplate(options?: ElementToVueOptions) {
+        return this.elements.map((element) => element.toVue(options) + '\n').join('');
+    }
+    /**
+     * 转换成 Vue 文件
+     */
+    toVue(options?: ElementToVueOptions) {
+        console.log(options);
+        let result = '';
+        result += `<template>\n${this.genVueTemplate(options)}\n</template>\n`;
+        result += `<script>\n${this.genScript()}\n</script>\n`;
+        return result;
+    }
+    /**
+     * 转换成设计器中使用的 Vue template 内容
+     * @param options
+     */
+    genDesignerVueTemplate(options?: ElementToVueOptions) {
+        return this.elements.map((element) => element.toDesignerVue(options) + '\n').join('');
+    }
+    /**
+     * 转换成设计器中使用的 Vue 文件
+     * 目前不需要 script 和 style
+     * @param options
+     */
+    toDesignerVue(options?: ElementToVueOptions) {
+        return `<template>\n${this.genDesignerVueTemplate(options)}</template>`;
+    }
+    /**
+     * 转换成 VueOptions
+     * @TODO 后面 template 可以优化成 render 函数
+     */
+    toVueOptions(options?: ElementToVueOptions) {
+        return {
+            template: this.genVueTemplate(options),
+            script: this.genScript(),
+        };
+    }
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name = this.name) {
+        return `/embedded/${this.app.name}/views/${name}.ts`;
+    }
+
+    getNamespace(): string {
+        if (this.parentNode) {
+            let parentNodeNamespace = (this.parentNode as Namespace).getNamespace();
+            if (this.parentNode.concept === 'View') {
+                parentNodeNamespace = `${(this.parentNode as View).getNamespace()}.${this.parentNode.name}`;
+            }
+            return `${parentNodeNamespace}.views`;
+        } else
+            throw new Error('无法获取命名空间，请设置 parentNode！');
+    }
+
+    get tsName() {
+        let tsName = this.name;
+        if (/^\d/.test(tsName)) {
+            tsName = '$' + tsName;
+        }
+        tsName = tsName.replaceAll('-', '_');
+        return tsName;
+    }
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState, parentName?: string): string {
+        const currentName = `${parentName ? parentName + '.views.' : ''}${this.tsName}`;
+        let code = `export namespace ${currentName} {\n`;
+        // 角色
+        // if (this.auth && Array.isArray(this.roles) && this.roles.length) {
+        //     code += indent(state.tabSize + 1);
+        //     code += 'export let roles = [\n';
+        //     this.roles.forEach((role) => {
+        //         code += indent(state.tabSize + 1);
+        //         `${this.app.getNamespace()}.${role.name}`;
+        //         code += `${role.namespace}.${role.name},`;
+        //         code += '\n';
+        //     });
+        //     code += indent(state.tabSize + 1);
+        //     code += '];\n';
+        // }
+        if (this.auth && Array.isArray(this.bindRoles) && this.bindRoles.length) {
+            code += indent(state.tabSize + 1);
+            code += 'export let bindRoles = [\n';
+            this.bindRoles.forEach((role) => {
+                code += indent(state.tabSize + 1);
+                code += `${this.app.getNamespace()}.roles.${role}.${role},`;
+                code += '\n';
+            });
+            code += '\n';
+            code += indent(state.tabSize + 1);
+            code += '];\n';
+        }
+        if (Array.isArray(this.params)) {
+            this.params.forEach((param) => {
+                code += indent(state.tabSize + 1) + 'let ';
+                code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            });
+        }
+        if (Array.isArray(this.variables)) {
+            this.variables.forEach((variable) => {
+                code += indent(state.tabSize + 1) + 'let ';
+                code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            });
+        }
+
+        // elements类型声明定义
+        code += indent(state.tabSize + 1) + `let __elements = {\n`;
+        // 生成所有的name和类型定义
+        this.elements.forEach((element) => {
+            code += element.toEmbeddedTSDefinition(shiftState(state, code, {
+                tabSize: state.tabSize + 1,
+            }));
+        });
+        code += indent(state.tabSize + 1) + '}\n';
+        // 逻辑
+        if (Array.isArray(this.logics) && this.logics.length) {
+            code += indent(state.tabSize + 1);
+            code += `export namespace logics {\n`;
+            this.logics.forEach((logic) => {
+                code += logic.toEmbeddedTS(shiftState(state, code, {
+                    tabSize: state.tabSize + 2,
+                }));
+                code += '\n';
+            });
+            code += indent(state.tabSize + 1);
+            code += '}\n';
+        }
+        // 事件
+        // bindEvent暂时不用生成，生成就会校验参数
+        // if (Array.isArray(this.events) && this.events.length) {
+        //     this.events.forEach((event) => {
+        //         code += event.toObjectTS(shiftState(state, code, {
+        //             tabSize: state.tabSize,
+        //         }));
+        //         code += '\n';
+        //     });
+        // }
+
+        // render函数
+        code += '\n' + indent(state.tabSize + 1);
+        code += `export function __render(`;
+        code += `){\n`;
+        code += indent(state.tabSize);
+
+        // elements 元素
+        if (Array.isArray(this.elements)) {
+            // 生成嵌套式的内容
+            this.elements.forEach((element) => {
+                code += element.toEmbeddedTS(shiftState(state, code, {
+                    tabSize: state.tabSize + 3,
+                }));
+                code += '\n';
+            });
+        }
+
+        code += '\n' + indent(state.tabSize + 1) + '}\n';
+
+        if (Array.isArray(this.params)) {
+            code += indent(state.tabSize + 1) + `export function $destination(`;
+            this.params.forEach((param, index) => {
+                code += `${param.toEmbeddedTS(shiftState(state, code, { inline: true }))}`;
+                if (index !== this.params.length - 1)
+                    code += ', ';
+            });
+            code += '){}\n';
+        }
+        code += indent(state.tabSize) + '}\n';
+        // 子页面
+        if (Array.isArray(this.children)) {
+            this.children.forEach((child) => {
+                code += child.toEmbeddedTS(shiftState(state, code), currentName);
+                code += '\n';
+            });
+        }
+
+        return code;
+    }
+
+    toEmbeddedTSFile() {
+        let code = `namespace ${this.getNamespace()} {\n`;
+        const state = createCompilerState(code, {
+            tabSize: 1,
+        });
+
+        code += this.toEmbeddedTS(state);
+
+        code += '}\n';
+
+        return {
+            code,
+            filePath: this.getEmbeddedFilePath(),
+            sourceMap: state.sourceMap,
+        };
+    }
+
+    get path() {
+        const _path = [];
+        let view: View = this;
+        while (view.concept === 'View') {
+            _path.push(view.name);
+            view = view.parentNode as View;
+        }
+        let path = '/';
+        if (_path.length) {
+            path += `${_path.join('/')}`;
+        }
+        return path;
+    }
+
+    _setAsIndexView(isIndex: boolean) {
+        let views: View[] = [];
+        if (this.parentNode.concept !== 'View') {
+            views = (this.parentNode as App).views;
+        } else if (this.parentNode.concept === 'View') {
+            views = (this.parentNode as View).children;
+        }
+        if (views.length) {
+            if (this.isIndex !== isIndex) {
+                this.setIsIndex(isIndex);
+            }
+            // 设为默认跳转页时，将之前的默认跳转页取消设置
+            if (isIndex) {
+                views.forEach((view) => {
+                    if (view !== this && view.isIndex) {
+                        view.setIsIndex(false);
+                    }
+                });
+            }
+        }
+    }
+
+    setAsIndexView(isIndex: boolean) {
+        this.rootNode.emit('collect:start');
+        this._setAsIndexView(isIndex);
+        this.rootNode.emit('collect:end');
+    }
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['View'] = View;
+export default View;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================