@lcap/nasl 0.3.14 → 1.0.0-alpha.1

package/src/concepts/ViewComponent__.ts

@@ -0,0 +1,1098 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 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 Attribute from './Attribute__';
+import Event from './Event__';
+import Slot from './Slot__';
+import Logic from './Logic__';
+import Module from './Module__';
+import App from './App__';
+
+/**
+ * 页面组件
+ */
+@concept
+export class ViewComponent extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'ViewComponent' = 'ViewComponent';
+
+    /**
+     * 页面组件名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 页面组件标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 页面组件描述
+     */
+    @property()
+    description: string = undefined;
+
+    /**
+     * category
+     */
+    @property()
+    category: string = undefined;
+
+    /**
+     * 组件属性列表
+     */
+    @property('Attribute')
+    attrs: Array<Attribute> = [];
+
+    /**
+     * 组件事件列表
+     */
+    @property('Event')
+    events: Array<Event> = [];
+
+    /**
+     * 插槽列表
+     */
+    @property('Slot')
+    slots: Array<Slot> = [];
+
+    /**
+     * 逻辑列表
+     */
+    @property('Logic')
+    methods: Array<Logic> = [];
+
+    /**
+     * 页面组件列表
+     */
+    @property('ViewComponent')
+    children: Array<ViewComponent> = [];
+
+    /**
+     * 祖先 Module
+     */
+    get module() {
+        return this.getAncestor('Module') as Module;
+    }
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ViewComponent>) {
+        source = Object.assign({}, ViewComponent.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): ViewComponent {
+        return super.from(source, parentNode, parentKey) as ViewComponent;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeViewComponent?.(this);
+        }
+        return params;
+    }
+    
+
+        getAttributeExistingNames(excludedList: Array<Attribute> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.attrs.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getAttributeUniqueName(name = 'attribute1') {
+        return utils.unique(name, this.getAttributeExistingNames());
+    }
+
+    /**
+    * 插入组件属性
+    * @internal
+    * @param name 组件属性名称，如果不填会自动生成一个唯一名称
+    */
+    _insertAttributeAt(name: string, index: number): Attribute;
+
+    /**
+    * 插入组件属性
+    * @internal
+    * @param attributeOptions 组件属性参数
+    */
+    _insertAttributeAt(attributeOptions: Partial<Attribute>, index: number): Attribute;
+
+    /**
+    * 插入组件属性
+    * @internal
+    * @param attribute 已有的组件属性实例
+    */
+    _insertAttributeAt(attribute: Attribute, index: number): Attribute;
+
+    _insertAttributeAt(options: string | Partial<Attribute> | Attribute, index: number) {
+        const attributeOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'attrs' };
+        let attribute: Attribute;
+        if (!options) {
+            attribute = Attribute.from({
+                ...attributeOptions,
+                name: this.getAttributeUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            attribute = Attribute.from({
+                ...attributeOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Attribute) {
+            options.delete(); // 同一实例不支持多处存在
+            attribute = options;
+        } else {
+            attribute = Attribute.from({
+                ...attributeOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(attribute, relationOptions);
+        this.attrs.splice(index, 0, attribute);
+        return attribute;
+    }
+
+    /**
+     * 插入组件属性
+     * @param name 组件属性名称，如果不填会自动生成一个唯一名称
+     */
+    insertAttributeAt(name: string, index: number): Attribute;
+
+    /**
+     * 插入组件属性
+     * @param attributeOptions 组件属性参数
+     */
+    insertAttributeAt(attributeOptions: Partial<Attribute>, index: number): Attribute;
+
+    /**
+     * 插入组件属性
+     * @param attribute 已有的组件属性实例
+     */
+    insertAttributeAt(attribute: Attribute, index: number): Attribute;
+
+    insertAttributeAt(options: string | Partial<Attribute> | Attribute, index: number) {
+        const node = this._insertAttributeAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'attrs',
+        });
+        return node;
+    }
+
+    /**
+     * 添加组件属性
+     * @internal
+     * @param name 组件属性名称，如果不填会自动生成一个唯一名称
+     */
+    _addAttribute(name?: string): Attribute;
+
+    /**
+     * 添加组件属性
+     * @internal
+     * @param attributeOptions 组件属性参数
+     */
+    _addAttribute(attributeOptions: Partial<Attribute>): Attribute;
+
+    /**
+     * 添加组件属性
+     * @internal
+     * @param attribute 已有的组件属性实例
+     */
+    _addAttribute(attribute: Attribute): Attribute;
+
+    _addAttribute(options?: string | Partial<Attribute> | Attribute) {
+        const index = this.attrs.length;
+        return this._insertAttributeAt(options as any, index);
+    }
+
+    /**
+     * 添加组件属性
+     * @internal
+     * @param name 组件属性名称，如果不填会自动生成一个唯一名称
+     */
+    addAttribute(name?: string): Attribute;
+
+    /**
+     * 添加组件属性
+     * @param attributeOptions 组件属性参数
+     */
+    addAttribute(attributeOptions: Partial<Attribute>): Attribute;
+
+    /**
+     * 添加组件属性
+     * @param attribute 已有的组件属性实例
+     */
+    addAttribute(attribute: Attribute): Attribute;
+
+    addAttribute(options?: string | Partial<Attribute> | Attribute) {
+        const node = this._addAttribute(options as any);
+        const index = this.attrs.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'attrs',
+        });
+        return node;
+    }
+
+
+    getEventExistingNames(excludedList: Array<Event> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.events.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getEventUniqueName(name = 'event1') {
+        return utils.unique(name, this.getEventExistingNames());
+    }
+
+    /**
+    * 插入组件事件
+    * @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' };
+        let event: Event;
+        if (!options) {
+            event = Event.from({
+                ...eventOptions,
+                name: this.getEventUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            event = Event.from({
+                ...eventOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Event) {
+            options.delete(); // 同一实例不支持多处存在
+            event = options;
+        } else {
+            event = Event.from({
+                ...eventOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(event, relationOptions);
+        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.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'events',
+        });
+        return node;
+    }
+
+
+    getSlotExistingNames(excludedList: Array<Slot> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.slots.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getSlotUniqueName(name = 'slot1') {
+        return utils.unique(name, this.getSlotExistingNames());
+    }
+
+    /**
+    * 插入插槽
+    * @internal
+    * @param name 插槽名称，如果不填会自动生成一个唯一名称
+    */
+    _insertSlotAt(name: string, index: number): Slot;
+
+    /**
+    * 插入插槽
+    * @internal
+    * @param slotOptions 插槽参数
+    */
+    _insertSlotAt(slotOptions: Partial<Slot>, index: number): Slot;
+
+    /**
+    * 插入插槽
+    * @internal
+    * @param slot 已有的插槽实例
+    */
+    _insertSlotAt(slot: Slot, index: number): Slot;
+
+    _insertSlotAt(options: string | Partial<Slot> | Slot, index: number) {
+        const slotOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'slots' };
+        let slot: Slot;
+        if (!options) {
+            slot = Slot.from({
+                ...slotOptions,
+                name: this.getSlotUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            slot = Slot.from({
+                ...slotOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Slot) {
+            options.delete(); // 同一实例不支持多处存在
+            slot = options;
+        } else {
+            slot = Slot.from({
+                ...slotOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(slot, relationOptions);
+        this.slots.splice(index, 0, slot);
+        return slot;
+    }
+
+    /**
+     * 插入插槽
+     * @param name 插槽名称，如果不填会自动生成一个唯一名称
+     */
+    insertSlotAt(name: string, index: number): Slot;
+
+    /**
+     * 插入插槽
+     * @param slotOptions 插槽参数
+     */
+    insertSlotAt(slotOptions: Partial<Slot>, index: number): Slot;
+
+    /**
+     * 插入插槽
+     * @param slot 已有的插槽实例
+     */
+    insertSlotAt(slot: Slot, index: number): Slot;
+
+    insertSlotAt(options: string | Partial<Slot> | Slot, index: number) {
+        const node = this._insertSlotAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'slots',
+        });
+        return node;
+    }
+
+    /**
+     * 添加插槽
+     * @internal
+     * @param name 插槽名称，如果不填会自动生成一个唯一名称
+     */
+    _addSlot(name?: string): Slot;
+
+    /**
+     * 添加插槽
+     * @internal
+     * @param slotOptions 插槽参数
+     */
+    _addSlot(slotOptions: Partial<Slot>): Slot;
+
+    /**
+     * 添加插槽
+     * @internal
+     * @param slot 已有的插槽实例
+     */
+    _addSlot(slot: Slot): Slot;
+
+    _addSlot(options?: string | Partial<Slot> | Slot) {
+        const index = this.slots.length;
+        return this._insertSlotAt(options as any, index);
+    }
+
+    /**
+     * 添加插槽
+     * @internal
+     * @param name 插槽名称，如果不填会自动生成一个唯一名称
+     */
+    addSlot(name?: string): Slot;
+
+    /**
+     * 添加插槽
+     * @param slotOptions 插槽参数
+     */
+    addSlot(slotOptions: Partial<Slot>): Slot;
+
+    /**
+     * 添加插槽
+     * @param slot 已有的插槽实例
+     */
+    addSlot(slot: Slot): Slot;
+
+    addSlot(options?: string | Partial<Slot> | Slot) {
+        const node = this._addSlot(options as any);
+        const index = this.slots.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'slots',
+        });
+        return node;
+    }
+
+
+    getLogicExistingNames(excludedList: Array<Logic> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.methods.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: 'methods' };
+        let logic: Logic;
+        if (!options) {
+            logic = Logic.from({
+                ...logicOptions,
+                name: this.getLogicUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            logic = Logic.from({
+                ...logicOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Logic) {
+            options.delete(); // 同一实例不支持多处存在
+            logic = options;
+        } else {
+            logic = Logic.from({
+                ...logicOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(logic, relationOptions);
+        this.methods.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: 'methods',
+        });
+        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.methods.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.methods.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'methods',
+        });
+        return node;
+    }
+
+
+    getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.children.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewComponentUniqueName(name = 'viewComponent1') {
+        return utils.unique(name, this.getViewComponentExistingNames());
+    }
+
+    /**
+    * 插入页面组件
+    * @internal
+    * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+    */
+    _insertViewComponentAt(name: string, index: number): ViewComponent;
+
+    /**
+    * 插入页面组件
+    * @internal
+    * @param viewComponentOptions 页面组件参数
+    */
+    _insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
+
+    /**
+    * 插入页面组件
+    * @internal
+    * @param viewComponent 已有的页面组件实例
+    */
+    _insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
+
+    _insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
+        const viewComponentOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'children' };
+        let viewComponent: ViewComponent;
+        if (!options) {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                name: this.getViewComponentUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof ViewComponent) {
+            options.delete(); // 同一实例不支持多处存在
+            viewComponent = options;
+        } else {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(viewComponent, relationOptions);
+        this.children.splice(index, 0, viewComponent);
+        return viewComponent;
+    }
+
+    /**
+     * 插入页面组件
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    insertViewComponentAt(name: string, index: number): ViewComponent;
+
+    /**
+     * 插入页面组件
+     * @param viewComponentOptions 页面组件参数
+     */
+    insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
+
+    /**
+     * 插入页面组件
+     * @param viewComponent 已有的页面组件实例
+     */
+    insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
+
+    insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
+        const node = this._insertViewComponentAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'children',
+        });
+        return node;
+    }
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    _addViewComponent(name?: string): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param viewComponentOptions 页面组件参数
+     */
+    _addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param viewComponent 已有的页面组件实例
+     */
+    _addViewComponent(viewComponent: ViewComponent): ViewComponent;
+
+    _addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
+        const index = this.children.length;
+        return this._insertViewComponentAt(options as any, index);
+    }
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    addViewComponent(name?: string): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @param viewComponentOptions 页面组件参数
+     */
+    addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @param viewComponent 已有的页面组件实例
+     */
+    addViewComponent(viewComponent: ViewComponent): ViewComponent;
+
+    addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
+        const node = this._addViewComponent(options as any);
+        const index = this.children.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'children',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除组件属性
+    * @param name 组件属性名称
+    */
+    removeAttribute(name: string): void;
+
+    /**
+     * 删除组件属性
+     * @param attribute 已有的组件属性实例
+     */
+    removeAttribute(attribute: Attribute): void;
+
+    removeAttribute(options: string | Attribute) {
+        let attribute: Attribute;
+        if (typeof options === 'string') {
+            attribute = this.attrs.find((item) => item.name === options);
+            if (!attribute) {
+                throw new Error('找不到组件属性 ' + options);
+            }
+        } else {
+            attribute = options;
+        }
+        return attribute.delete();
+    }
+
+    __removeAttribute(attribute: Attribute) {
+        const parentKey = attribute.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: attribute,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(attribute);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === attribute) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除组件事件
+    * @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.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;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(event);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === event) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除插槽
+    * @param name 插槽名称
+    */
+    removeSlot(name: string): void;
+
+    /**
+     * 删除插槽
+     * @param slot 已有的插槽实例
+     */
+    removeSlot(slot: Slot): void;
+
+    removeSlot(options: string | Slot) {
+        let slot: Slot;
+        if (typeof options === 'string') {
+            slot = this.slots.find((item) => item.name === options);
+            if (!slot) {
+                throw new Error('找不到插槽 ' + options);
+            }
+        } else {
+            slot = options;
+        }
+        return slot.delete();
+    }
+
+    __removeSlot(slot: Slot) {
+        const parentKey = slot.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: slot,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(slot);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === slot) {
+                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.methods.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 页面组件名称
+    */
+    removeViewComponent(name: string): void;
+
+    /**
+     * 删除页面组件
+     * @param viewComponent 已有的页面组件实例
+     */
+    removeViewComponent(viewComponent: ViewComponent): void;
+
+    removeViewComponent(options: string | ViewComponent) {
+        let viewComponent: ViewComponent;
+        if (typeof options === 'string') {
+            viewComponent = this.children.find((item) => item.name === options);
+            if (!viewComponent) {
+                throw new Error('找不到页面组件 ' + options);
+            }
+        } else {
+            viewComponent = options;
+        }
+        return viewComponent.delete();
+    }
+
+    __removeViewComponent(viewComponent: ViewComponent) {
+        const parentKey = viewComponent.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: viewComponent,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(viewComponent);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === viewComponent) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['ViewComponent'] = ViewComponent;
+export default ViewComponent;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================