@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/common/BaseNode.ts

@@ -9,7 +9,7 @@ import { loadThen } from '../service/storage/storagePoint';
 
 import { EventEmitter, EventPayload, Params } from './EventEmitter';
 import * as utils from '../utils';
-import classMap from '../common/classMap';
+import classMap from './classMap';
 import { action, circular, excludedInJSON, property, getConceptConstructor, getConceptPropertyMap } from '../decorators';
 import { Diagnostic } from '../manager/diagnostic';
 import type { ViewElement, TypeAnnotation, App } from '..';
@@ -18,1107 +18,1185 @@ import { sentryMonitorNaslNode } from '../sentry';
 import operations from '../breakpoint/shared/operations';
 import type { SynatxNode, SynatxNodeConcept } from '../concepts';
 
+// 确保属性都是定义过的
+function ensureDefined(object: any, concept: string) {
+  if (!object) {
+    return object;
+  }
+  const newObject: any = {};
+  const actualConcept = object?.concept || concept;
+  if (actualConcept) {
+    const propertyMap = getConceptPropertyMap(actualConcept);
+    for (const key in object) {
+      const property = propertyMap.get(key);
+      if (property) {
+        const objProperty = object[key] ?? null;
+        const propertyConcept = property?.objectRef;
+        if (propertyConcept) {
+          if (Array.isArray(objProperty)) {
+            newObject[key] = objProperty.map((objItem: any) => {
+              return ensureDefined(objItem, propertyConcept);
+            });
+          } else {
+            newObject[key] = ensureDefined(objProperty, propertyConcept);
+          }
+        } else {
+          newObject[key] = objProperty;
+        }
+      }
+    }
+  }
+  return newObject;
+}
+
 /**
  * 顶点类
  * 属性均为只读，仅在初始化和 load 的情况下可以修改
  */
 @sentryMonitorNaslNode
 export class BaseNode extends EventEmitter {
+  /**
+   * 可修改标志，内部属性
+   * 标记在构造函数结束后是否可修改
+   */
+  @excludedInJSON()
+  _mutable = true;
+
+  /**
+   * 概念
+   */
+  @property()
+  concept: string = undefined;
+
+  /**
+   * toJSON 时需要去除的键，为了避免出现 CircularJSON
+   */
+  readonly JSON_EXCLUDED_KEYS: Set<string>;
+
+  /**
+   * 唯一 Id
+   */
+  id: string = uuidv4().replace(/-/g, '');
+
+  /**
+   * 变动时间
+   */
+  @property()
+  changedTime: number = undefined;
+
+  /**
+   * 分支名称
+   */
+  @property()
+  branchName: string = undefined;
+
+  /**
+   * 合并代码相关
+   */
+  @property()
+  workingCopy: object = undefined;
+
+  @property()
+  branch: object = undefined;
+
+  /**
+   * 断点状态
+   * undefined ==> 未设置
+   * null ==> 已删除
+   * 'ENABLED' ==> 启用断点
+   * 'DISABLED' ==> 禁用断点
+   */
+  @property()
+  breakpoint: 'ENABLED' | 'DISABLED' | null | undefined = undefined;
+
+  /**
+   * 父节点
+   */
+  @circular()
+  parentNode: SynatxNode = null;
+
+  parentKey: string = '';
+
+  /**
+   * 是否正在编辑
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  editable: boolean = undefined;
+
+  /**
+   * 是否可以删除
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  removable: boolean = undefined;
+
+  /**
+   * 是否正在编辑
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  editing: boolean = false;
+
+  /**
+   * 是否正在请求
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  loading: boolean = false;
+
+  /**
+   * 节点是否为展开状态
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  expanded: boolean = false;
+
+  /**
+   * 节点是否显示
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  hidden: boolean = false;
+
+  /**
+   * 页面树节点是否显示
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  pageTreeNodeHidden: boolean = false;
+
+  /**
+   * 逻辑树节点是否显示
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  logicTreeNodeHidden: boolean = false;
+
+  /**
+   * 数据树节点是否显示
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  dataTreeNodeHidden: boolean = false;
+
+  /**
+   * 数据树节点是否展开
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  logicTreeNodeExpanded: boolean = false;
+
+  /**
+   * 用于挂 embeddedTS 的 sourceMap
+   */
+  @excludedInJSON()
+  sourceMap: SourceMap = undefined;
+
+  /**
+   * 是否为叶子节点
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  isLeaf: boolean = false;
+
+  @excludedInJSON()
+  storageJSON: any;
+
+  /**
+   * 当前节点上报错详细信息
+   */
+  tsErrorDetail: Diagnostic | undefined = undefined;
+
+  @property()
+  name: string = '';
+
+  /**
+   * 当前节点的类型标注
+   */
+  @excludedInJSON()
+  __TypeAnnotation: TypeAnnotation = undefined;
+
+  /**
+   * 当前节点的类型标注是不是正确的
+   */
+  @excludedInJSON()
+  __isCorrectTypeAnnotation: boolean = false;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<BaseNode>) {
+    super();
+    if (this.hasOwnProperty('JSON_EXCLUDED_KEYS') && this.JSON_EXCLUDED_KEYS === undefined) delete (this as any).JSON_EXCLUDED_KEYS;
     /**
-     * 可修改标志，内部属性
-     * 标记在构造函数结束后是否可修改
-     */
-    @excludedInJSON()
-    _mutable = true;
-    /**
-     * 概念
-     */
-    @property()
-    concept: string = undefined;
-    /**
-     * toJSON 时需要去除的键，为了避免出现 CircularJSON
-     */
-    readonly JSON_EXCLUDED_KEYS: Set<string>;
-    /**
-     * 唯一 Id
-     */
-    id: string = uuidv4().replace(/-/g, '');
-    /**
-     * 变动时间
-     */
-    @property()
-    changedTime: number = undefined;
-    /**
-     * 分支名称
-     */
-    @property()
-    branchName: string = undefined;
-    /**
-     * 合并代码相关
-     */
-    @property()
-    workingCopy: object = undefined;
-    @property()
-    branch: object = undefined;
-    /**
-     * 断点状态
-     * undefined ==> 未设置
-     * null ==> 已删除
-     * 'ENABLED' ==> 启用断点
-     * 'DISABLED' ==> 禁用断点
-     */
-    @property()
-    breakpoint: 'ENABLED' | 'DISABLED' | null | undefined = undefined;
-    /**
-     * 父节点
-     */
-    @circular()
-    parentNode: SynatxNode = null;
-
-    parentKey: string = '';
-    /**
-     * 是否正在编辑
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    editable: boolean = undefined;
-    /**
-     * 是否可以删除
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    removable: boolean = undefined;
-    /**
-     * 是否正在编辑
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    editing: boolean = false;
-    /**
-     * 是否正在请求
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    loading: boolean = false;
-    /**
-     * 节点是否为展开状态
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    expanded: boolean = false;
-    /**
-     * 节点是否显示
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    hidden: boolean = false;
-    /**
-     * 页面树节点是否显示
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    pageTreeNodeHidden: boolean = false;
-    /**
-     * 逻辑树节点是否显示
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    logicTreeNodeHidden: boolean = false;
-    /**
-     * 数据树节点是否显示
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    dataTreeNodeHidden: boolean = false;
-    /**
-     * 数据树节点是否展开
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    logicTreeNodeExpanded: boolean = false;
-    /**
-     * 用于挂 embeddedTS 的 sourceMap
-     */
-    @excludedInJSON()
-    sourceMap: SourceMap = undefined;
-    /**
-     * 是否为叶子节点
-     * 前端 UI 状态
-     */
-    @excludedInJSON()
-    isLeaf: boolean = false;
-    @excludedInJSON()
-    storageJSON: any;
-    /**
-     * 当前节点上报错详细信息
+     * 监听action，delete，update事件
      */
-    tsErrorDetail: Diagnostic | undefined = undefined;
-
-    @property()
-    name: string = '';
+    this.on('create', this.genActionListener);
+    this.on('delete', this.genActionListener);
+    this.on('update', this.genActionListener);
 
     /**
-     * 当前节点的类型标注
-     */
-    @excludedInJSON()
-    __TypeAnnotation: TypeAnnotation = undefined;
-    /**
-     * 当前节点的类型标注是不是正确的
+     * 监听action，delete，update事件
      */
-    @excludedInJSON()
-    __isCorrectTypeAnnotation: boolean = false;
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<BaseNode>) {
-        super();
-        if (this.hasOwnProperty('JSON_EXCLUDED_KEYS') && this.JSON_EXCLUDED_KEYS === undefined)
-            delete (this as any).JSON_EXCLUDED_KEYS;
-        /**
-         * 监听action，delete，update事件
-         */
-        this.on('create', this.genActionListener);
-        this.on('delete', this.genActionListener);
-        this.on('update', this.genActionListener);
-
-        /**
-         * 监听action，delete，update事件
-         */
-        this.on('create', () => operations.create(this));
-        this.on('delete', () => operations.delete(this));
-        this.on('update', () => operations.update(this));
-    }
-
-    // static constructorName = 'BaseNode'
-    getClassName() {
-        return 'BaseNode';
+    this.on('create', () => operations.create(this));
+    this.on('delete', () => operations.delete(this));
+    this.on('update', () => operations.update(this));
+  }
+
+  // static constructorName = 'BaseNode'
+  getClassName() {
+    return 'BaseNode';
+  }
+
+  subConstructor(source?: Partial<BaseNode>) {
+    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
+    const properties = Array.from(new Set([...Object.keys(this), ...Object.keys(source)])).filter((key) => propertyMap.has(key));
+
+    // 测试时用的标记属性
+    if (process.env.NODE_ENV === 'testing') {
+      properties.push('__$Selected');
     }
-    subConstructor(source?: Partial<BaseNode>) {
-        const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
-        const properties = Array.from(new Set([...Object.keys(this), ...Object.keys(source)])).filter((key) => propertyMap.has(key));
 
-        // 测试时用的标记属性
-        if (process.env.NODE_ENV === 'testing') {
-            properties.push('__$Selected');
-        }
-
-        properties.forEach((key) => {
-            const property = propertyMap.get(key);
-            const sourceItem = (source as any)[key] !== undefined ? (source as any)[key] : (this as any)[key];
-            let objectRefCtor: any;
-            try {
-                if (property?.objectRef) {
-                    const arr = property.objectRef.split(' | ');
-                    for (let i = 0; i < arr.length; i++) {
-                        objectRefCtor = getConceptConstructor(arr[i]);
-                        if (sourceItem instanceof objectRefCtor) {
-                            sourceItem.parentNode = this;
-                            sourceItem.parentKey = key;
-                            break;
-                        }
-                    }
-                }
-                // 数组的情况也在这里做掉了
-                (this as any)[key] = objectRefCtor && sourceItem && !(sourceItem instanceof objectRefCtor) ? this.instantiateSub(sourceItem, key) : sourceItem;
-            } catch (e) {
-                // Function has non-object prototype 'undefined' in instanceof check
-                if (!e.message.includes('Function has non-object prototype'))
-                    throw e;
-            }
-        });
-        operations.create(this);
-        // if (config.storage.protocol === 'http' && loadThen[source.concept as 'App' | 'View']) {
-        //     const { childNodes } = loadThen[source.concept as 'App' | 'View'] || {};
-        //     const queryList = childNodes.map(({ field, concept }) => {
-        //         const path = [this.nodePath, field].join('.');
-        //         return {
-        //             path,
-        //             excludes: loadThen[concept as 'App' | 'View'].childNodes.map(({ field }) => field),
-        //         };
-        //     });
-        //     storageService
-        //         .batchQuery({
-        //             body: queryList,
-        //             headers: {
-        //                 appId: this.rootNode?.id || this.id,
-        //             },
-        //         })
-        //         .then((data: any) =>
-        //             data.forEach((sourceItem: any, index: number) => {
-        //                 const { field, concept } = childNodes[index];
-        //                 if (!sourceItem || (Array.isArray((this as any)[field]) && !Array.isArray(sourceItem))) {
-        //                     return;
-        //                 }
-        //                 const objectRefCtor = getConceptConstructor(concept);
-        //                 (this as any)[field] = objectRefCtor ? this.instantiateSub(sourceItem, field) : sourceItem;
-        //             }));
-        // }
-    }
-
-    fixInstantiate() {
-        const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
-
-        const properties = Object.keys(this).filter((key) => propertyMap.has(key));
-        properties.forEach((key) => {
-            const property = propertyMap.get(key);
-            const sourceItem = (this as any)[key];
-            const objectRefCtor = property.objectRef && getConceptConstructor(property.objectRef);
-            if (objectRefCtor) {
-                if (Array.isArray(sourceItem)) {
-                    sourceItem.forEach((item, index) => {
-                        if (item instanceof objectRefCtor) {
-                            item.parentNode = this;
-                            item.parentKey = key;
-                            item.fixInstantiate();
-                        } else {
-                            sourceItem[index] = this.instantiateSub(item instanceof BaseNode ? item.toJSON() : item, key);
-                        }
-                    });
-                } else {
-                    if (sourceItem instanceof objectRefCtor) {
-                        sourceItem.parentNode = this;
-                        sourceItem.parentKey = key;
-                        sourceItem.fixInstantiate();
-                    } else {
-                        (this as any)[key] = this.instantiateSub(sourceItem instanceof BaseNode ? sourceItem.toJSON() : sourceItem, key);
-                    }
-                }
+    properties.forEach((key) => {
+      const property = propertyMap.get(key);
+      const sourceItem = (source as any)[key] !== undefined ? (source as any)[key] : (this as any)[key];
+      let objectRefCtor: any;
+      try {
+        if (property?.objectRef) {
+          const arr = property.objectRef.split(' | ');
+          for (let i = 0; i < arr.length; i++) {
+            objectRefCtor = getConceptConstructor(arr[i]);
+            if (sourceItem instanceof objectRefCtor) {
+              sourceItem.parentNode = this;
+              sourceItem.parentKey = key;
+              break;
             }
-        });
-    }
-
-    getIndexOfParent() {
-        let index = -1;
-        const parentNode = this.parentNode;
-        if (parentNode) {
-            const parentKey = this.parentKey;
-            const parentProperty = (parentNode as any)[parentKey];
-            if (Array.isArray(parentProperty)) {
-                index = parentProperty.indexOf(this);
-            }
-        }
-        return index;
-    }
-
-    /**
-     * 为存储点生成行为监听器
-     * @param action
-     * @returns
-     */
-    genActionListener($event: EventPayload) {
-        // eventList是要被发送给后端的数据
-        if (!$event.eventList) {
-            $event.eventList = [];
-        }
-        if (!$event.eventStop) {
-            $event.eventList.push($event);
+          }
         }
-        $event.originEvent = $event.originEvent || $event;
-        this.onChange($event);
-        if (this.concept === 'App') {
-            this.emit('storage', $event);
-        } else if (this.parentNode && this.parentNode.emit) {
-            const event: EventPayload = {
-                action: 'update',
-                path: this.parentNode?.getNodePath(false),
-                object: {},
-                oldObject: {},
-                originEvent: $event.originEvent,
-                eventList: $event.eventList,
-                // eventStop为true后，数据不再存入eventList，就不再会将冒泡数据发送给后端
-                eventStop: true,
-            };
-            this.parentNode?.emit('update', event);
-        }
-    }
-
-    createNode({ parentNode, parentKey, index }: { parentNode: SynatxNode; parentKey: string; index: number }) {
-        if (parentNode) {
-            const property = parentNode[parentKey as keyof SynatxNode];
-            if (Array.isArray(property) && index !== -1) {
-                property.splice(index, 0, this);
+        // 数组的情况也在这里做掉了
+        (this as any)[key] =
+          objectRefCtor && sourceItem && !(sourceItem instanceof objectRefCtor) ? this.instantiateSub(sourceItem, key) : sourceItem;
+      } catch (e) {
+        // Function has non-object prototype 'undefined' in instanceof check
+        if (!e.message.includes('Function has non-object prototype')) throw e;
+      }
+    });
+    operations.create(this);
+    // if (config.storage.protocol === 'http' && loadThen[source.concept as 'App' | 'View']) {
+    //     const { childNodes } = loadThen[source.concept as 'App' | 'View'] || {};
+    //     const queryList = childNodes.map(({ field, concept }) => {
+    //         const path = [this.nodePath, field].join('.');
+    //         return {
+    //             path,
+    //             excludes: loadThen[concept as 'App' | 'View'].childNodes.map(({ field }) => field),
+    //         };
+    //     });
+    //     storageService
+    //         .batchQuery({
+    //             body: queryList,
+    //             headers: {
+    //                 appId: this.rootNode?.id || this.id,
+    //             },
+    //         })
+    //         .then((data: any) =>
+    //             data.forEach((sourceItem: any, index: number) => {
+    //                 const { field, concept } = childNodes[index];
+    //                 if (!sourceItem || (Array.isArray((this as any)[field]) && !Array.isArray(sourceItem))) {
+    //                     return;
+    //                 }
+    //                 const objectRefCtor = getConceptConstructor(concept);
+    //                 (this as any)[field] = objectRefCtor ? this.instantiateSub(sourceItem, field) : sourceItem;
+    //             }));
+    // }
+  }
+
+  fixInstantiate() {
+    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
+
+    const properties = Object.keys(this).filter((key) => propertyMap.has(key));
+    properties.forEach((key) => {
+      const property = propertyMap.get(key);
+      const sourceItem = (this as any)[key];
+      const objectRefCtor = property.objectRef && getConceptConstructor(property.objectRef);
+      if (objectRefCtor) {
+        if (Array.isArray(sourceItem)) {
+          sourceItem.forEach((item, index) => {
+            if (item instanceof objectRefCtor) {
+              item.parentNode = this;
+              item.parentKey = key;
+              item.fixInstantiate();
             } else {
-                (parentNode as any)[parentKey] = this;
+              sourceItem[index] = this.instantiateSub(item instanceof BaseNode ? item.toJSON() : item, key);
             }
-            this.parentNode = parentNode;
-            this.parentKey = parentKey;
-            this.create({
-                index,
-                parentKey,
-            });
+          });
+        } else if (sourceItem instanceof objectRefCtor) {
+          sourceItem.parentNode = this;
+          sourceItem.parentKey = key;
+          sourceItem.fixInstantiate();
+        } else {
+          (this as any)[key] = this.instantiateSub(sourceItem instanceof BaseNode ? sourceItem.toJSON() : sourceItem, key);
         }
+      }
+    });
+  }
+
+  getIndexOfParent() {
+    let index = -1;
+    const { parentNode } = this;
+    if (parentNode) {
+      const { parentKey } = this;
+      const parentProperty = (parentNode as any)[parentKey];
+      if (Array.isArray(parentProperty)) {
+        index = parentProperty.indexOf(this);
+      }
     }
-
-    toTemplateJSON() {
-        return this._toJSON((source) => {
-            delete source.id;
-            return source;
-        });
+    return index;
+  }
+
+  /**
+   * 为存储点生成行为监听器
+   * @param action
+   * @returns
+   */
+  genActionListener($event: EventPayload) {
+    // eventList是要被发送给后端的数据
+    if (!$event.eventList) {
+      $event.eventList = [];
     }
-
-    /**
-     * 创建节点
-     */
-    create(parentParams: Params) {
-        this.emit('create', {
-            action: 'create',
-            path: this.getNodePath(true),
-            object: this.toJSON(),
-            ...parentParams,
-            oldObject: null,
-        });
+    if (!$event.eventStop) {
+      $event.eventList.push($event);
     }
-
-    /**
-     * 如果有父节点，则删除节点，在添加时调用
-     */
-    ensureDelete() {
-        // 批量赋值因为连线的问题需要特殊处理一下.
-        if (this.parentNode?.concept === 'SelectMembers') {
-            this.parentNode.ensureDelete();
-            return;
-        }
-
-        if (this.parentNode && this.parentKey) {
-            const path = this.getNodePath(false);
-            const parentParams = this._delete();
-            if (parentParams && parentParams.index !== -1) {
-                if (Array.isArray((this.parentNode as any)[this.parentKey])) {
-                    this.emit('delete', {
-                        action: 'delete',
-                        path,
-                        object: null,
-                        ...parentParams,
-                    });
-                } else {
-                    const parentPath = this.parentNode.getNodePath(false);
-                    this.parentNode.emit('update', {
-                        action: 'update',
-                        path: parentPath,
-                        object: {
-                            [this.parentKey]: null,
-                        },
-                        oldObject: {
-                            [this.parentKey]: this.toJSON(),
-                        },
-                    });
-                }
-            }
-        }
+    $event.originEvent = $event.originEvent || $event;
+    this.onChange($event);
+    if (this.concept === 'App') {
+      this.emit('storage', $event);
+    } else if (this.parentNode && this.parentNode.emit) {
+      const event: EventPayload = {
+        action: 'update',
+        path: this.parentNode?.getNodePath(false),
+        object: {},
+        oldObject: {},
+        originEvent: $event.originEvent,
+        eventList: $event.eventList,
+        // eventStop为true后，数据不再存入eventList，就不再会将冒泡数据发送给后端
+        eventStop: true,
+      };
+      this.parentNode?.emit('update', event);
     }
-
-    /**
-     * 删除节点
-     */
-    delete() {
-        if (this.parentNode?.concept === 'Match' && this.parentKey === 'expression') {
-            (this.parentNode as any).setExpressionWitchCase(null);
-            return;
-        }
-        // 批量赋值因为连线的问题需要特殊处理一下.
-        if (this.parentNode?.concept === 'SelectMembers') {
-            const node: any = this.parentNode;
-            node.delete();
-            return;
-        } else if (this.concept === 'SelectMembers') {
-            const node: any = this.parentNode;
-            node.changeLinesLocation(this);
-        }
-
-        const useIndex = ['BindEvent', 'Identifier'].includes(this.concept);
-        const path = this.getNodePath(useIndex);
-        const parentParams = this._delete();
-        if (parentParams && parentParams.index !== -1) {
-            if (Array.isArray((this.parentNode as any)[this.parentKey])) {
-                this.emit('delete', {
-                    action: 'delete',
-                    path,
-                    object: null,
-                    ...parentParams,
-                });
-            } else {
-                const parentPath = this.parentNode.getNodePath(false);
-                this.parentNode.emit('update', {
-                    action: 'update',
-                    path: parentPath,
-                    object: {
-                        [this.parentKey]: null,
-                    },
-                    oldObject: {
-                        [this.parentKey]: this.toJSON(),
-                    },
-                });
-            }
-        }
+  }
+
+  createNode({ parentNode, parentKey, index }: { parentNode: SynatxNode; parentKey: string; index: number }) {
+    if (parentNode) {
+      const property = parentNode[parentKey as keyof SynatxNode];
+      if (Array.isArray(property) && index !== -1) {
+        property.splice(index, 0, this);
+      } else {
+        (parentNode as any)[parentKey] = this;
+      }
+      this.parentNode = parentNode;
+      this.parentKey = parentKey;
+      this.create({
+        index,
+        parentKey,
+      });
     }
-
-    /**
-     * 更新节点
-     */
-    update({ field, ...object }: any) {
-        // const useIndexKeys = ['Module'];
-        const path = this.getNodePath(false);
-        const oldObject: any = {};
-        for (const key in object) {
-            if (Object.prototype.hasOwnProperty.call(object, key)) {
-                const oldProperty = (this as any)[key] ?? null;
-                oldObject[key] = oldProperty;
-                if (Array.isArray(oldProperty)) {
-                    oldObject[key] = oldProperty.map((item) => {
-                        let propertyItem = item ?? null;
-                        if (item instanceof BaseNode) {
-                            propertyItem = item.toJSON();
-                        }
-                        return propertyItem;
-                    });
-                } else if (oldProperty instanceof BaseNode) {
-                    oldObject[key] = oldProperty.toJSON();
-                }
-                const property = object[key] ?? null;
-                (this as any)[key] = property;
-                const objectRefCtor = getConceptConstructor(property?.concept);
-                if (Array.isArray(property)) {
-                    (this as any)[key] = property.map((item) => {
-                        let propertyItem = item ?? null;
-                        const propertyObjectRefCtor = getConceptConstructor(item?.concept);
-                        if (propertyObjectRefCtor?.from) {
-                            propertyItem = (propertyObjectRefCtor as any).from(item, this, key);
-                        }
-                        return propertyItem;
-                    });
-                } else if (objectRefCtor?.from) {
-                    (this as any)[key] = (objectRefCtor as any).from(property, this, key);
-                }
-            }
-        }
-        this.emit('update', {
-            action: 'update',
-            path,
-            object,
-            oldObject,
-            field,
-        });
+  }
+
+  toTemplateJSON() {
+    return this._toJSON((source) => {
+      delete source.id;
+      return source;
+    });
+  }
+
+  /**
+   * 创建节点
+   */
+  create(parentParams: Params) {
+    this.emit('create', {
+      action: 'create',
+      path: this.getNodePath(true),
+      object: this.toJSON(),
+      ...parentParams,
+      oldObject: null,
+    });
+  }
+
+  /**
+   * 如果有父节点，则删除节点，在添加时调用
+   */
+  ensureDelete() {
+    // 批量赋值因为连线的问题需要特殊处理一下.
+    if (this.parentNode?.concept === 'SelectMembers') {
+      this.parentNode.ensureDelete();
+      return;
     }
 
-    _delete(): Params {
-        /* override */
-        return {
-            propertyName: '',
-            index: -1,
+    if (this.parentNode && this.parentKey) {
+      const path = this.getNodePath(false);
+      const parentParams = this._delete();
+      if (parentParams && parentParams.index !== -1) {
+        if (Array.isArray((this.parentNode as any)[this.parentKey])) {
+          this.emit('delete', {
+            action: 'delete',
+            path,
             object: null,
-            oldObject: this,
-        };
-    }
-
-    static from(source: any, parentNode?: BaseNode, parentKey?: string): BaseNode {
-        // 有一些继承的情况
-        const Ctor = classMap?.[source?.concept] || this;
-        if (Ctor && source instanceof Ctor) {
-            if (parentNode) {
-                source.parentNode = parentNode;
-            }
-            if (parentKey) {
-                source.parentKey = parentKey;
-            }
-            return source;
-        }
-
-        if (Ctor) {
-            const instance = new Ctor();
-            if (parentNode) {
-                instance.parentNode = parentNode;
-            }
-            if (parentKey) {
-                instance.parentKey = parentKey;
-            }
-            instance.subConstructor({
-                ...source,
-                concept: source.concept || this?.prototype?.getClassName() || Ctor.name,
-                parentNode,
-            });
-            return instance;
-        }
-    }
-
-    get nodePath() {
-        return this.getNodePath(false);
-    }
-
-    getNodePath(useIndex: boolean): string
-    getNodePath(useIndexKeys: string[]): string
-    getNodePath(useIndex: boolean | string[]) {
-        let node: BaseNode = this;
-        let useIndexKeys: string[] = [];
-        if (Array.isArray(useIndex)) {
-            useIndexKeys = useIndex;
-            useIndex = false;
-        }
-        let isNodeSelf = true;
-        const pathArr = [];
-        while (node) {
-            let path = '';
-            const parentNode = node.parentNode;
-            if (parentNode) {
-                const parentKey = node.parentKey;
-                path = parentKey;
-                const parentProperty = parentNode[parentKey as keyof BaseNode];
-                if (Array.isArray(parentProperty)) {
-                    const name = node.name;
-                    if (!name || (useIndex && isNodeSelf) || useIndexKeys.includes(node.concept)) {
-                        const index = parentProperty.indexOf(node);
-                        path += `[${index}]`;
-                    } else {
-                        path += `[name=${name}]`;
-                    }
-                }
-                pathArr.unshift(path);
-            }
-            node = parentNode;
-            isNodeSelf = false;
+            ...parentParams,
+          });
+        } else {
+          const parentPath = this.parentNode.getNodePath(false);
+          this.parentNode.emit('update', {
+            action: 'update',
+            path: parentPath,
+            object: {
+              [this.parentKey]: null,
+            },
+            oldObject: {
+              [this.parentKey]: this.toJSON(),
+            },
+          });
         }
-        pathArr.unshift('app');
-        return pathArr.join('.');
+      }
     }
-
-    /**
-     * 上层节点
-     */
-    get upperNode(): SynatxNode {
-        // eslint-disable-next-line consistent-this
-        let _upperNode: BaseNode = this;
-        while (!!_upperNode && _upperNode.concept === this.concept) {
-            _upperNode = _upperNode.parentNode;
-        }
-        return _upperNode as SynatxNode;
+  }
+
+  /**
+   * 删除节点
+   */
+  delete() {
+    if (this.parentNode?.concept === 'Match' && this.parentKey === 'expression') {
+      (this.parentNode as any).setExpressionWitchCase(null);
+      return;
     }
-
-    /**
-     * 根节点
-     */
-    get rootNode() {
-        return this.getAncestor('App') as App;
+    // 批量赋值因为连线的问题需要特殊处理一下.
+    if (this.parentNode?.concept === 'SelectMembers') {
+      const node: any = this.parentNode;
+      node.delete();
+      return;
     }
-
-    /**
-     * 获取祖先节点
-     */
-    getAncestor(concept: SynatxNode['concept']): SynatxNode;
-    getAncestor<Node extends SynatxNode>(concept: Node['concept']): Node;
-    getAncestor<Node extends SynatxNode = SynatxNode>(concept: SynatxNode['concept']): Node {
-        let upperNode = this.upperNode;
-        while (upperNode && upperNode.concept && upperNode.concept !== concept) {
-            upperNode = upperNode.upperNode;
-        }
-        return upperNode as Node;
+    if (this.concept === 'SelectMembers') {
+      const node: any = this.parentNode;
+      node.changeLinesLocation(this);
     }
 
-    /**
-     *
-     * @param source
-     * @param Ctor
-     * @param completeList
-     * @param idsList
-     */
-    handleSource(source: any, completeList: any[]) {
-        const { id, concept } = source || {};
-        const actualSource = source instanceof BaseNode ? source : getSourceFromMap(id, concept);
-        completeList.push(actualSource || source);
+    const useIndex = ['BindEvent', 'Identifier'].includes(this.concept);
+    const path = this.getNodePath(useIndex);
+    const parentParams = this._delete();
+    if (parentParams && parentParams.index !== -1) {
+      if (Array.isArray((this.parentNode as any)[this.parentKey])) {
+        this.emit('delete', {
+          action: 'delete',
+          path,
+          object: null,
+          ...parentParams,
+        });
+      } else {
+        const parentPath = this.parentNode.getNodePath(false);
+        this.parentNode.emit('update', {
+          action: 'update',
+          path: parentPath,
+          object: {
+            [this.parentKey]: null,
+          },
+          oldObject: {
+            [this.parentKey]: this.toJSON(),
+          },
+        });
+      }
     }
-
-    /**
-     * 获取当前的TsName
-     */
-    get tsName() {
-        if (this.name) {
-            let tsName = this.name;
-            // 匹配所有特殊字符都转为_
-            tsName = tsName.replace(/\W/g, '_');
-            if (/^\d/.test(tsName)) {
-                tsName = '$' + tsName;
+  }
+
+  /**
+   * 更新节点
+   */
+  update({ field, ...object }: any) {
+    const path = this.getNodePath(false);
+    const oldObject: any = {};
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        const oldProperty = (this as any)[key] ?? null;
+        oldObject[key] = oldProperty;
+        if (Array.isArray(oldProperty)) {
+          oldObject[key] = oldProperty.map((item) => {
+            let propertyItem = item ?? null;
+            if (item instanceof BaseNode) {
+              propertyItem = item.toJSON();
             }
-            return tsName;
-        }
-        return '';
-    }
-
-    /**
-     * 生成json
-     * @param instance
-     * @param Ctor
-     */
-    genSources(instance: BaseNode, filerFn?: (source: Partial<BaseNode>) => {}) {
-        if (!instance) {
-            return instance;
+            return propertyItem;
+          });
+        } else if (oldProperty instanceof BaseNode) {
+          oldObject[key] = oldProperty.toJSON();
         }
-        if (Array.isArray(instance)) {
-            return instance.map((item) => (item && item._toJSON ? item._toJSON(filerFn) : item));
-        } else {
-            return instance && instance._toJSON ? instance._toJSON(filerFn) : instance;
-        }
-    }
-
-    /**
-     * 实例化一个 JSON
-     * 由于有 from，只能先实例化父级，再实例化子级
-     * @param obj
-     * @param parentNode
-     * @returns
-     */
-    instantiate(source: any, parentNode: BaseNode, parentKey: string) {
-        if (source instanceof BaseNode) {
-            if (!source.parentNode || !source.parentKey) {
-                source.parentNode = parentNode as SynatxNode;
-                source.parentKey = parentKey;
+        const property = object[key] ?? null;
+        (this as any)[key] = property;
+        const objectRefCtor = getConceptConstructor(property?.concept);
+        if (Array.isArray(property)) {
+          (this as any)[key] = property.map((item) => {
+            let propertyItem = item ?? null;
+            const propertyObjectRefCtor = getConceptConstructor(item?.concept);
+            if (propertyObjectRefCtor?.from) {
+              propertyItem = (propertyObjectRefCtor as any).from(item, this, key);
             }
-            return source;
-        } else if (source && source.concept && classMap[source.concept]) {
-            const Ctor = classMap[source.concept] as any;
-            const instance = Ctor.from(source, parentNode, parentKey);
-            if (instance && instance.toStorageJSON)
-                instance.storageJSON = instance.toStorageJSON();
-            return instance;
-        } else {
-            return source;
+            return propertyItem;
+          });
+        } else if (objectRefCtor?.from) {
+          (this as any)[key] = (objectRefCtor as any).from(property, this, key);
         }
+      }
     }
-
-    /**
-     * 激活 JSON 内部实例
-     * @param source
-     */
-    instantiateSub(source: any, parentKey: string) {
-        if (!source) {
-            return;
-        }
-        const completeList: any[] = [];
-        let isArray = false;
-        // 暂时通过是否有name判断数据是否全
-        if (Array.isArray(source)) {
-            isArray = true;
-            source.forEach((sourceItem) => {
-                this.handleSource(sourceItem, completeList);
+    const newObject: any = {};
+    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
+    for (const key in object) {
+      const property = propertyMap.get(key);
+      if (property) {
+        const objProperty = object[key] ?? null;
+        const propertyConcept = property?.objectRef;
+        if (propertyConcept) {
+          if (Array.isArray(objProperty)) {
+            newObject[key] = objProperty.map((objItem: any) => {
+              return ensureDefined(objItem, propertyConcept);
             });
+          } else {
+            newObject[key] = ensureDefined(objProperty, propertyConcept);
+          }
         } else {
-            this.handleSource(source, completeList);
-        }
-        const instanceList: any[] = completeList.map((item) => this.instantiate(item, this, parentKey));
-        if (isArray) {
-            return instanceList;
-        } else if (Array.isArray(instanceList) && instanceList.length) {
-            return instanceList[0];
+          newObject[key] = objProperty;
         }
+      }
     }
-
-    plainAssign(source: any) {
-        this._mutable = true;
-
-        const oldId = this.id;
-
-        Object.keys(source).forEach((key) => {
-            const value = source[key];
-            if (typeof value !== 'object' && typeof value !== 'function')
-                (this as any)[key] = value;
-        });
-
-        this._mutable = false;
+    this.emit('update', {
+      action: 'update',
+      path,
+      object: newObject,
+      oldObject,
+      field,
+    });
+  }
+
+  _delete(): Params {
+    /* override */
+    return {
+      propertyName: '',
+      index: -1,
+      object: null,
+      oldObject: this,
+    };
+  }
+
+  static from(source: any, parentNode?: BaseNode, parentKey?: string): BaseNode {
+    // 有一些继承的情况
+    const Ctor = classMap?.[source?.concept] || this;
+    if (Ctor && source instanceof Ctor) {
+      if (parentNode) {
+        source.parentNode = parentNode;
+      }
+      if (parentKey) {
+        source.parentKey = parentKey;
+      }
+      return source;
     }
 
-    pick(source: any, keys: Array<string> = []) {
-        const obj: { [name: string]: any } = {};
-        keys.forEach((key) => (obj[key] = source[key]));
-        // 这里统一用 assign，集中处理 id 的问题
-        // this.assign(obj);
+    if (Ctor) {
+      const instance = new Ctor();
+      if (parentNode) {
+        instance.parentNode = parentNode;
+      }
+      if (parentKey) {
+        instance.parentKey = parentKey;
+      }
+      instance.subConstructor({
+        ...source,
+        concept: source.concept || this?.prototype?.getClassName() || Ctor.name,
+        parentNode,
+      });
+      return instance;
     }
-    /**
-     * 从对象中深度获取
-     * @param source
-     * @param keys
-     * @example 比如一般后端返回只是添加了个 id
-     * ```
-     * this.deepPick(result, ['id'])
-     */
-    deepPick(source: any, keys: Array<string> = []) {
-        utils.traverse((current) => {
-            const subSource = current.jsonPath ? at(source, [current.jsonPath])[0] : source;
-            const target = current.jsonPath ? at(this as any, [current.jsonPath])[0] : this;
-            if (!target)
-                return;
-
-            const obj: { [name: string]: any } = {};
-            keys.forEach((key) => {
-                if (subSource.hasOwnProperty(key)) {
-                    obj[key] = subSource[key];
-                }
-            });
-            // 这里统一用 assign，集中处理 id 的问题
-            target.assign ? target.assign(obj) : Object.assign(target, obj);
-        }, { node: source }, { mode: 'anyObject' });
+  }
+
+  get nodePath() {
+    return this.getNodePath(false);
+  }
+
+  getNodePath(useIndex: boolean): string;
+  getNodePath(useIndexKeys: string[]): string;
+  getNodePath(useIndex: boolean | string[]) {
+    let node: BaseNode = this;
+    let useIndexKeys: string[] = [];
+    if (Array.isArray(useIndex)) {
+      useIndexKeys = useIndex;
+      useIndex = false;
     }
-    /**
-     * 去除循环依赖，转为纯 JSON
-     * @param parentKey 外面的 key，提供给 JSON.stringify 使用
-     * @param excludedKeys 需要额外排除的 keys
-     */
-    toJSON() {
-        return this._toJSON();
+    let isNodeSelf = true;
+    const pathArr = [];
+    while (node) {
+      let path = '';
+      const { parentNode } = node;
+      if (parentNode) {
+        const { parentKey } = node;
+        path = parentKey;
+        const parentProperty = parentNode[parentKey as keyof BaseNode];
+        if (Array.isArray(parentProperty)) {
+          const { name } = node;
+          // 如果存在同名节点，使用下标来表示NodePath
+          const siblingNode: BaseNode = name
+            ? (parentProperty as BaseNode[]).find((child) => {
+                // 因为proxy的关系，导致两边的引用不相同，所以这里需要判断id
+                return child?.name === name && child !== node && child?.id !== node?.id;
+              })
+            : null;
+          if (siblingNode || !name || (useIndex && isNodeSelf) || useIndexKeys.includes(node.concept)) {
+            const index = parentProperty.indexOf(node);
+            path += `[${index}]`;
+          } else {
+            path += `[name=${name}]`;
+          }
+        }
+        pathArr.unshift(path);
+      }
+      node = parentNode;
+      isNodeSelf = false;
     }
-
-    _toJSON(filerFn?: (source: Partial<BaseNode>) => {}): any {
-        const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
-        const source: Partial<BaseNode> = {};
-        propertyMap.forEach((property, key: string) => {
-            if (property) {
-                const { objectRef: propertyObjectRef } = property;
-                if (!propertyObjectRef) {
-                    (source as any)[key] = this[key as keyof BaseNode];
-                } else {
-                    const sources: any = this.genSources(this[key as keyof BaseNode], filerFn);
-                    (source as any)[key] = sources;
-                }
-            }
-        });
-        return filerFn ? filerFn(source) : source;
+    pathArr.unshift('app');
+    return pathArr.join('.');
+  }
+
+  /**
+   * 上层节点
+   */
+  get upperNode(): SynatxNode {
+    // eslint-disable-next-line consistent-this
+    let _upperNode: BaseNode = this;
+    while (!!_upperNode && _upperNode.concept === this.concept) {
+      _upperNode = _upperNode.parentNode;
     }
-    /**
-     * 转为单层的 JSON
-     * @param parentKey 外面的 key，提供给 JSON.stringify 使用
-     * @param excludedKeys 需要额外排除的 keys
-     */
-    toPlainJSON(parentKey?: string, excludedKeys: Array<string> = []): any {
-        const JSON_EXCLUDED_KEYS = new Set(this.JSON_EXCLUDED_KEYS || []); // Object.getPrototypeOf(this).constructor.JSON_EXCLUDED_KEYS || [];
-        excludedKeys.forEach((key) => JSON_EXCLUDED_KEYS.add(key));
-
-        const temp: { [prop: string]: any } = {};
-        Object.keys(this).forEach((key) => {
-            const value = (this as any)[key];
-            if (!JSON_EXCLUDED_KEYS.has(key) && typeof value !== 'object' && typeof value !== 'function')
-                temp[key] = value;
-        });
-        return JSON.parse(JSON.stringify(temp));
+    return _upperNode as SynatxNode;
+  }
+
+  /**
+   * 根节点
+   */
+  get rootNode() {
+    return this.getAncestor('App') as App;
+  }
+
+  /**
+   * 获取祖先节点
+   */
+  getAncestor(concept: SynatxNode['concept']): SynatxNode;
+  getAncestor<Node extends SynatxNode>(concept: Node['concept']): Node;
+  getAncestor<Node extends SynatxNode = SynatxNode>(concept: SynatxNode['concept']): Node {
+    let { upperNode } = this;
+    while (upperNode && upperNode.concept && upperNode.concept !== concept) {
+      upperNode = upperNode.upperNode;
     }
-    /**
-     * 查找引用
-     */
-    @action('查找引用')
-    async findUsage(): Promise<any> {
-        /* override */
+    return upperNode as Node;
+  }
+
+  /**
+   *
+   * @param source
+   * @param Ctor
+   * @param completeList
+   * @param idsList
+   */
+  handleSource(source: any, completeList: any[]) {
+    const { id, concept } = source || {};
+    const actualSource = source instanceof BaseNode ? source : getSourceFromMap(id, concept);
+    completeList.push(actualSource || source);
+  }
+
+  /**
+   * 获取当前的TsName
+   */
+  get tsName() {
+    if (this.name) {
+      let tsName = this.name;
+      // 匹配所有特殊字符都转为_
+      tsName = tsName.replace(/\W/g, '_');
+      if (/^\d/.test(tsName)) {
+        tsName = `$${tsName}`;
+      }
+      return tsName;
     }
-
-    /**
-     * 通过当前节点，查找被引用的节点
-     */
-    @action('通过当前节点，查找被引用的节点')
-    async nodeFindRefNodes(): Promise<any> {
-        /* override */
+    return '';
+  }
+
+  /**
+   * 生成json
+   * @param instance
+   * @param Ctor
+   */
+  genSources(instance: BaseNode, filerFn?: (source: Partial<BaseNode>) => {}) {
+    if (!instance) {
+      return instance;
     }
-
-    async findReadOnlyLogicUsage(): Promise<any> {
-        /* override */
+    if (Array.isArray(instance)) {
+      return instance.map((item) => (item && item._toJSON ? item._toJSON(filerFn) : item));
     }
-
-    /**
-     * 重命名
-     */
-    @action('重命名')
-    async changeName(newValue: string): Promise<any> {
-        /* override */
+    return instance && instance._toJSON ? instance._toJSON(filerFn) : instance;
+  }
+
+  /**
+   * 实例化一个 JSON
+   * 由于有 from，只能先实例化父级，再实例化子级
+   * @param obj
+   * @param parentNode
+   * @returns
+   */
+  instantiate(source: any, parentNode: BaseNode, parentKey: string) {
+    if (source instanceof BaseNode) {
+      if (!source.parentNode || !source.parentKey) {
+        source.parentNode = parentNode as SynatxNode;
+        source.parentKey = parentKey;
+      }
+      return source;
     }
-
-    /**
-     * 准备删除
-     */
-    @action('准备删除')
-    async prepareDelete(cb?: Function): Promise<any> {
-        /* override */
+    if (source && source.concept && classMap[source.concept]) {
+      const Ctor = classMap[source.concept] as any;
+      const instance = Ctor.from(source, parentNode, parentKey);
+      if (instance && instance.toStorageJSON) instance.storageJSON = instance.toStorageJSON();
+      return instance;
     }
-
-    /**
-     * 添加参数准备
-     */
-    @action('添加参数准备')
-    async addParamsPrepare(): Promise<any> {
-        /* override */
+    return source;
+  }
+
+  /**
+   * 激活 JSON 内部实例
+   * @param source
+   */
+  instantiateSub(source: any, parentKey: string) {
+    if (!source) {
+      return;
     }
-
-    /**
-     * 获取当前节点类型
-     */
-    @action('获取当前节点类型')
-    async getCurrentTypeAnnotation(): Promise<any> {
-        /* override */
+    const completeList: any[] = [];
+    let isArray = false;
+    // 暂时通过是否有name判断数据是否全
+    if (Array.isArray(source)) {
+      isArray = true;
+      source.forEach((sourceItem) => {
+        this.handleSource(sourceItem, completeList);
+      });
+    } else {
+      this.handleSource(source, completeList);
     }
-    /**
-     * 获取当前节点的下一级内容
-     */
-    @action('获取当前节点的下一级内容')
-    getSelectRef(newTypeAnnotation: TypeAnnotation, needNewStructure = false): any {
-        /* override */
+    const instanceList: any[] = completeList.map((item) => this.instantiate(item, this, parentKey));
+    if (isArray) {
+      return instanceList;
     }
-    /**
-     * 销毁
-     * 从 Map 中删除点和子节点
-     */
-    destroy() {
-        // utils.traverse((current) => , { node: this }, {
-        //     mode: 'anyObject',
-        //     excludedKeySet: this.JSON_EXCLUDED_KEYS,
-        // });
+    if (Array.isArray(instanceList) && instanceList.length) {
+      return instanceList[0];
     }
+  }
+
+  plainAssign(source: any) {
+    this._mutable = true;
+
+    const oldId = this.id;
+
+    Object.keys(source).forEach((key) => {
+      const value = source[key];
+      if (typeof value !== 'object' && typeof value !== 'function') (this as any)[key] = value;
+    });
+
+    this._mutable = false;
+  }
+
+  pick(source: any, keys: Array<string> = []) {
+    const obj: { [name: string]: any } = {};
+    keys.forEach((key) => (obj[key] = source[key]));
+    // 这里统一用 assign，集中处理 id 的问题
+    // this.assign(obj);
+  }
+
+  /**
+   * 从对象中深度获取
+   * @param source
+   * @param keys
+   * @example 比如一般后端返回只是添加了个 id
+   * ```
+   * this.deepPick(result, ['id'])
+   */
+  deepPick(source: any, keys: Array<string> = []) {
+    utils.traverse(
+      (current) => {
+        const subSource = current.jsonPath ? at(source, [current.jsonPath])[0] : source;
+        const target = current.jsonPath ? at(this as any, [current.jsonPath])[0] : this;
+        if (!target) return;
 
-    onChange($event?: EventPayload) {
-        /* override */
+        const obj: { [name: string]: any } = {};
+        keys.forEach((key) => {
+          if (subSource.hasOwnProperty(key)) {
+            obj[key] = subSource[key];
+          }
+        });
+        // 这里统一用 assign，集中处理 id 的问题
+        target.assign ? target.assign(obj) : Object.assign(target, obj);
+      },
+      { node: source },
+      { mode: 'anyObject' }
+    );
+  }
+
+  /**
+   * 去除循环依赖，转为纯 JSON
+   * @param parentKey 外面的 key，提供给 JSON.stringify 使用
+   * @param excludedKeys 需要额外排除的 keys
+   */
+  toJSON() {
+    return this._toJSON();
+  }
+
+  _toJSON(filerFn?: (source: Partial<BaseNode>) => {}): any {
+    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
+    const source: Partial<BaseNode> = {};
+    propertyMap.forEach((property, key: string) => {
+      if (property) {
+        const { objectRef: propertyObjectRef } = property;
+        if (!propertyObjectRef) {
+          (source as any)[key] = this[key as keyof BaseNode];
+        } else {
+          const sources: any = this.genSources(this[key as keyof BaseNode], filerFn);
+          (source as any)[key] = sources;
+        }
+      }
+    });
+    return filerFn ? filerFn(source) : source;
+  }
+
+  /**
+   * 转为单层的 JSON
+   * @param parentKey 外面的 key，提供给 JSON.stringify 使用
+   * @param excludedKeys 需要额外排除的 keys
+   */
+  toPlainJSON(parentKey?: string, excludedKeys: Array<string> = []): any {
+    const JSON_EXCLUDED_KEYS = new Set(this.JSON_EXCLUDED_KEYS || []); // Object.getPrototypeOf(this).constructor.JSON_EXCLUDED_KEYS || [];
+    excludedKeys.forEach((key) => JSON_EXCLUDED_KEYS.add(key));
+
+    const temp: { [prop: string]: any } = {};
+    Object.keys(this).forEach((key) => {
+      const value = (this as any)[key];
+      if (!JSON_EXCLUDED_KEYS.has(key) && typeof value !== 'object' && typeof value !== 'function') temp[key] = value;
+    });
+    return JSON.parse(JSON.stringify(temp));
+  }
+
+  /**
+   * 查找引用
+   */
+  @action('查找引用')
+  async findUsage(): Promise<any> {
+    /* override */
+  }
+
+  /**
+   * 通过当前节点，查找被引用的节点
+   */
+  @action('通过当前节点，查找被引用的节点')
+  async nodeFindRefNodes(): Promise<any> {
+    /* override */
+  }
+
+  async findReadOnlyLogicUsage(): Promise<any> {
+    /* override */
+  }
+
+  /**
+   * 重命名
+   */
+  @action('重命名')
+  async changeName(newValue: string, updateAll: boolean = false): Promise<any> {
+    /* override */
+  }
+
+  /**
+   * 准备删除
+   */
+  @action('准备删除')
+  async prepareDelete(cb?: Function): Promise<any> {
+    /* override */
+  }
+
+  /**
+   * 添加参数准备
+   */
+  @action('添加参数准备')
+  async addParamsPrepare(): Promise<any> {
+    /* override */
+  }
+
+  /**
+   * 获取当前节点类型
+   */
+  @action('获取当前节点类型')
+  async getCurrentTypeAnnotation(): Promise<any> {
+    /* override */
+  }
+
+  /**
+   * 获取当前节点的下一级内容
+   */
+  @action('获取当前节点的下一级内容')
+  getSelectRef(newTypeAnnotation: TypeAnnotation, needNewStructure = false): any {
+    /* override */
+  }
+
+  /**
+   * 销毁
+   * 从 Map 中删除点和子节点
+   */
+  destroy() {
+    // utils.traverse((current) => , { node: this }, {
+    //     mode: 'anyObject',
+    //     excludedKeySet: this.JSON_EXCLUDED_KEYS,
+    // });
+  }
+
+  onChange($event?: EventPayload) {
+    this.emit('change', $event);
+  }
+
+  onCreate($event?: any) {
+    /* override */
+  }
+
+  onDelete($event?: any) {
+    /* override */
+  }
+
+  /**
+   * 移动节点
+   * @param sourceNode
+   * @param position
+   */
+  moveNode(options: { sourceNode: BaseNode; position: 'append' | 'insertBefore' | 'insertAfter'; action?: string }) {
+    const { sourceNode, position } = options;
+    if (this.concept === 'App') {
+      return;
     }
-    onCreate($event?: any) {
-        /* override */
+    let actionMsg = `移动${(this.constructor as any).nodeTitle}`;
+    if (this.name) {
+      actionMsg += `“${this.name}”`;
     }
-    onDelete($event?: any) {
-        /* override */
+    (sourceNode as any).app.emit('collect:start', {
+      actionMsg,
+    });
+    // 如果是兄弟节点之前的移动
+    if (position !== 'append' && this.concept !== sourceNode.concept) {
+      return;
     }
-
-    /**
-     * 移动节点
-     * @param sourceNode
-     * @param position
-     */
-    moveNode(options: {
-        sourceNode: BaseNode,
-        position: 'append' | 'insertBefore' | 'insertAfter',
-        action?: string
-    }) {
-        const { sourceNode, position } = options;
-        if (this.concept === 'App') {
-            return;
-        }
-        let actionMsg = `移动${(this.constructor as any).nodeTitle}`;
-        if (this.name) {
-            actionMsg += `“${this.name}”`;
+    // 先删
+    this.delete();
+    if (position === 'append') {
+      let { action } = options;
+      if (!action) action = `add${this.concept}`;
+      const parentNode = sourceNode;
+      (parentNode as any)[action](this as any);
+    } else {
+      const parentNode = sourceNode?.parentNode;
+      const parentKey = sourceNode?.parentKey || '';
+      const list = (parentNode as any)[parentKey];
+      if (Array.isArray(list)) {
+        let index = list.indexOf(sourceNode);
+        if (position === 'insertAfter') {
+          index += 1;
         }
-        (sourceNode as any).app.emit('collect:start', {
-            actionMsg,
+        Object.assign(this, {
+          parentNode,
+          parentKey,
         });
-        // 如果是兄弟节点之前的移动
-        if (position !== 'append' && this.concept !== sourceNode.concept) {
-            return;
-        }
-        // 先删
-        this.delete();
-        if (position === 'append') {
-            let { action } = options;
-            if (!action)
-                action = `add${this.concept}`;
-            const parentNode = sourceNode;
-            (parentNode as any)[action](this as any);
-        } else {
-            const parentNode = sourceNode?.parentNode;
-            const parentKey = sourceNode?.parentKey || '';
-            const list = (parentNode as any)[parentKey];
-            if (Array.isArray(list)) {
-                let index = list.indexOf(sourceNode);
-                if (position === 'insertAfter') {
-                    index += 1;
-                }
-                Object.assign(this, {
-                    parentNode,
-                    parentKey,
-                });
-
-                if (this.concept === 'ViewElement')
-                    this.name = (this as unknown as ViewElement).getViewElementUniqueName(this.name);
-
-                list.splice(index, 0, this);
-                this.create({
-                    index,
-                    parentNode,
-                    parentKey,
-                });
-            }
-        }
-        (sourceNode as any).app.emit('collect:end');
-    }
 
-    // 其他节点替换本nasl节点
-    replaceNode(newNode: any) {
-        const oldNode: any = this;
-        const { parentNode, parentKey, offsetX, offsetY, app } = oldNode;
-        const logic = oldNode.logic;
-        if (!Array.isArray(parentNode[parentKey])) {
-            /**
-             * match切换分支，需要调用setExpressionWitchCase，补全分支的信息
-             */
-            if (parentNode.concept === 'Match' && parentKey === 'expression') {
-                parentNode.setExpressionWitchCase(newNode);
-                return;
-            }
-            parentNode.update({
-                [parentKey]: newNode,
-            });
+        if (this.concept === 'ViewElement') this.name = (this as unknown as ViewElement).getViewElementUniqueName(this.name);
+
+        list.splice(index, 0, this);
+        this.create({
+          index,
+          parentNode,
+          parentKey,
+        });
+      }
+    }
+    (sourceNode as any).app.emit('collect:end');
+  }
+
+  // 其他节点替换本nasl节点
+  replaceNode(newNode: any) {
+    const oldNode: any = this;
+    const { parentNode, parentKey, offsetX, offsetY, app } = oldNode;
+    const { logic } = oldNode;
+    if (!Array.isArray(parentNode[parentKey])) {
+      /**
+       * match切换分支，需要调用setExpressionWitchCase，补全分支的信息
+       */
+      if (parentNode.concept === 'Match' && parentKey === 'expression') {
+        parentNode.setExpressionWitchCase(newNode);
+        return;
+      }
+      parentNode.update({
+        [parentKey]: newNode,
+      });
+    } else {
+      app.emit('collect:start', {
+        actionMsg: '删除属性变量',
+      });
+      if (parentNode.concept === 'Logic') {
+        if (parentKey === 'body') {
+          const expIndex = logic.body.findIndex((item: any) => item === oldNode);
+          logic.insertItemInBodyAt(newNode, expIndex);
         } else {
-            app.emit('collect:start', {
-                actionMsg: '删除属性变量',
-            });
-            if (parentNode.concept === 'Logic') {
-                if (parentKey === 'body') {
-                    const expIndex = logic.body.findIndex((item: any) => item === oldNode);
-                    logic.insertItemInBodyAt(newNode, expIndex);
-                } else {
-                    const expIndex = logic.playground.findIndex((item: any) => item === oldNode);
-                    Object.assign(newNode, { offsetX, offsetY });
-                    logic.insertItemInPlaygroundAt(newNode, expIndex);
-                }
-            } else {
-                const expIndex = parentNode[parentKey].findIndex((item: any) => item === oldNode);
-                const firstUpperText = parentKey[0].toUpperCase() + parentKey.slice(1, parentKey.length);
-                Object.assign(newNode, { offsetX, offsetY });
-                if (parentNode.concept === 'MatchCase') {
-                    parentKey === 'body' ? parentNode.insertItemInBodyAt(newNode, expIndex) : parentNode.insertLogicItemInPatternsAt(newNode, expIndex);
-                } else if (parentNode[`insertItemIn${firstUpperText}At`])
-                    parentNode[`insertItemIn${firstUpperText}At`](newNode, expIndex);
-                else
-                    parentNode.insertItemAt(newNode, expIndex);
-            }
-            oldNode.delete();
-            app.emit('collect:end');
+          const expIndex = logic.playground.findIndex((item: any) => item === oldNode);
+          Object.assign(newNode, { offsetX, offsetY });
+          logic.insertItemInPlaygroundAt(newNode, expIndex);
         }
+      } else {
+        const expIndex = parentNode[parentKey].findIndex((item: any) => item === oldNode);
+        const firstUpperText = parentKey[0].toUpperCase() + parentKey.slice(1, parentKey.length);
+        Object.assign(newNode, { offsetX, offsetY });
+        if (parentNode.concept === 'MatchCase') {
+          parentKey === 'body' ? parentNode.insertItemInBodyAt(newNode, expIndex) : parentNode.insertLogicItemInPatternsAt(newNode, expIndex);
+        } else if (parentNode[`insertItemIn${firstUpperText}At`]) parentNode[`insertItemIn${firstUpperText}At`](newNode, expIndex);
+        else parentNode.insertItemAt(newNode, expIndex);
+      }
+      oldNode.delete();
+      app.emit('collect:end');
     }
-
-    /**
-     * 获取添加时的默认选项
-     * @returns
-     */
-    public static getDefaultOptions(): any {
-        return {};
+  }
+
+  /**
+   * 获取添加时的默认选项
+   * @returns
+   */
+  public static getDefaultOptions(): any {
+    return {};
+  }
+
+  public traverseChildren(cb: (ele: SynatxNode) => void): void {
+    function traverse(node: SynatxNode) {
+      cb(node);
+
+      const propertyMap = getConceptPropertyMap(node?.concept);
+      if (!propertyMap) return;
+
+      for (const property of propertyMap.keys()) {
+        const child = node[property as keyof BaseNode];
+        if (!child) continue;
+        else if (Array.isArray(child)) child.forEach((node: SynatxNode) => traverse(node));
+        else traverse(child);
+      }
     }
 
-    public traverseChildren(cb: (ele: SynatxNode) => void): void {
-        function traverse(node: SynatxNode) {
-            cb(node);
-
-            const propertyMap = getConceptPropertyMap(node?.concept);
-            if (!propertyMap)
-                return;
-
-            for (const property of propertyMap.keys()) {
-                const child = node[property as keyof BaseNode];
-                if (!child)
-                    continue;
-                else if (Array.isArray(child))
-                    child.forEach((node: SynatxNode) => traverse(node));
-                else
-                    traverse(child);
-            }
-        }
-
-        traverse(this as unknown as SynatxNode);
+    traverse(this as unknown as SynatxNode);
+  }
+
+  /**
+   *  获取当前节点在nasl标注节点上的节点
+   */
+  public getCurrentAnnotatedJSON() {
+    return this.__TypeAnnotation;
+  }
+
+  /**
+   *  获取
+   *  当前this上下文 的Source 和 父级文件级别的节点
+   */
+  public getCurrentSource() {
+    const node = this as BaseNode;
+    let { sourceMap } = node;
+    let fileNode = node;
+    // 如果没有sourceMap,就继续向上找 ,或者到module结束
+    // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+    // 如果当前节点是view就不要向上查找了
+    while (!sourceMap && fileNode && !(fileNode.parentNode.concept === 'App')) {
+      fileNode = fileNode.parentNode;
+      sourceMap = fileNode?.sourceMap;
     }
-
-    /**
-     *  获取当前节点在nasl标注节点上的节点
-     */
-    public getCurrentAnnotatedJSON() {
-        return this.__TypeAnnotation;
+    const currentSource = sourceMap && sourceMap.get(node);
+    if (currentSource) {
+      return { currentSource, fileNode };
     }
-    /**
-     *  获取
-     *  当前this上下文 的Source 和 父级文件级别的节点
-     */
-    public getCurrentSource() {
-        const node = (this as BaseNode);
-        let sourceMap = node.sourceMap;
-        let fileNode = node;
-        // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
-        // 如果当前节点是view就不要向上查找了
-        while (
-            !sourceMap
-            && fileNode
-            && !(fileNode.parentNode.concept === 'App')
-        ) {
-            fileNode = fileNode.parentNode;
-            sourceMap = fileNode?.sourceMap;
-        }
-        const currentSource = sourceMap && sourceMap.get(node);
-        if (currentSource) {
-            return { currentSource, fileNode };
-        }
-        return { fileNode };
+    return { fileNode };
+  }
+
+  /**
+   *  获取
+   *  当前this上下文 的Source 和 父级文件级别的节点
+   */
+  public getFileConceptNode(concept: string) {
+    const node = this as BaseNode;
+    let { sourceMap } = node;
+    let fileNode = node;
+    // 如果没有sourceMap,就继续向上找 ,或者到module结束
+    // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+    // 如果当前节点是view就不要向上查找了
+    while (!sourceMap && fileNode && !(fileNode.parentNode.concept === 'App')) {
+      fileNode = fileNode.parentNode;
+      sourceMap = fileNode?.sourceMap;
     }
-
-    /**
-     *  获取
-     *  当前this上下文 的Source 和 父级文件级别的节点
-     */
-    public getFileConceptNode(concept: string) {
-        const node = (this as BaseNode);
-        let sourceMap = node.sourceMap;
-        let fileNode = node;
-        // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
-        // 如果当前节点是view就不要向上查找了
-        while (
-            !sourceMap
-            && fileNode
-            && !(fileNode.parentNode.concept === 'App')
-        ) {
-            fileNode = fileNode.parentNode;
-            sourceMap = fileNode?.sourceMap;
-        }
-        const arr: any = [];
-        sourceMap && sourceMap.forEach((value, key) => {
-            if (key.concept === concept)
-                arr.push({ key, value });
-        });
-        return arr;
+    const arr: any = [];
+    sourceMap &&
+      sourceMap.forEach((value, key) => {
+        if (key.concept === concept) arr.push({ key, value });
+      });
+    return arr;
+  }
+
+  get isTreeLeaf() {
+    if (
+      this.concept === 'EntityProperty' ||
+      this.concept === 'InterfaceParam' ||
+      this.concept === 'Param' ||
+      this.concept === 'Return' ||
+      this.concept === 'StructureProperty' ||
+      this.concept === 'Variable'
+    ) {
+      if ((this as any).typeAnnotation || (this.__TypeAnnotation && this.parentKey === 'virtualParams')) {
+        return !this.hasChildren;
+      }
+      return true;
     }
-    get isTreeLeaf() {
-        if (this.concept === 'EntityProperty' || this.concept === 'InterfaceParam' || this.concept === 'Param'
-            || this.concept === 'Return' || this.concept === 'StructureProperty' || this.concept === 'Variable') {
-            if ((this as any).typeAnnotation || (this.__TypeAnnotation && this.parentKey === 'virtualParams')) {
-                return !this.hasChildren;
-            } else {
-                return true;
-            }
-        }
-        return false;
+    return false;
+  }
+
+  get hasChildren() {
+    const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
+    if (typeAnnotation) {
+      const { typeKind, typeNamespace, typeName, properties } = typeAnnotation;
+      if (typeKind === 'reference' || typeKind === 'generic') {
+        if (typeNamespace.endsWith('.enums')) return null;
+        return [{}];
+      }
+      if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+        return [{}];
+      }
+      if (typeKind === 'anonymousStructure' && properties?.length) {
+        return [{}];
+      }
+      return null;
     }
-    get hasChildren() {
-        const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
-        if (typeAnnotation) {
-            const { typeKind, typeNamespace, typeName, properties } = typeAnnotation;
-            if (typeKind === 'reference' || typeKind === 'generic') {
-                if (typeNamespace.endsWith('.enums'))
-                    return null;
-                return [{}];
-            } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
-                return [{}];
-            } else if (typeKind === 'anonymousStructure' && properties?.length) {
-                return [{}];
-            }
-            return null;
-        }
-        return null;
+    return null;
+  }
+
+  /** 收集特定类型的子节点 */
+  collectNodes(concept: SynatxNodeConcept): void;
+  /** 收集判定为真的子节点 */
+  collectNodes(pre: (node: SynatxNode) => boolean): void;
+  collectNodes(input: SynatxNodeConcept | ((node: SynatxNode) => boolean)) {
+    const pre = typeof input === 'string' ? (node: SynatxNode) => node.concept === input : input;
+    const nodes: SynatxNode[] = [];
+    const self = this as unknown as SynatxNode;
+
+    if (pre(self)) {
+      nodes.push(self);
     }
 
-    /** 收集特定类型的子节点 */
-    collectNodes(concept: SynatxNodeConcept): void;
-    /** 收集判定为真的子节点 */
-    collectNodes(pre: (node: SynatxNode) => boolean): void;
-    collectNodes(input: SynatxNodeConcept | ((node: SynatxNode) => boolean)) {
-        const pre = typeof input === 'string' ? (node: SynatxNode) => node.concept === input : input;
-        const nodes: SynatxNode[] = [];
-        const self = this as unknown as SynatxNode;
-
-        if (pre(self)) {
-            nodes.push(self);
-        }
+    this.traverseChildren((current) => {
+      if (pre(current)) {
+        nodes.push(current);
+      }
+    });
 
-        this.traverseChildren((current) => {
-            if (pre(current)) {
-                nodes.push(current);
-            }
-        });
-
-        return nodes;
-    }
+    return nodes;
+  }
 }
 
 export default BaseNode;