@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.1

package/src/common/dist/BaseNode.js

@@ -0,0 +1,1101 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.BaseNode = void 0;
+var lodash_1 = require("lodash");
+var uuid_1 = require("uuid");
+var map_1 = require("../service/storage/map");
+var EventEmitter_1 = require("./EventEmitter");
+var utils = require("../utils");
+var classMap_1 = require("../common/classMap");
+var decorators_1 = require("../decorators");
+var __1 = require("..");
+/**
+ * 顶点类
+ * 属性均为只读，仅在初始化和 load 的情况下可以修改
+ */
+var BaseNode = /** @class */ (function (_super) {
+    __extends(BaseNode, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function BaseNode(source) {
+        var _this = _super.call(this) || this;
+        /**
+         * 可修改标志，内部属性
+         * 标记在构造函数结束后是否可修改
+         */
+        _this._mutable = true;
+        /**
+         * 概念
+         */
+        _this.concept = undefined;
+        /**
+         * 唯一 Id
+         */
+        _this.id = uuid_1.v4().replace(/-/g, '');
+        /**
+         * 变动时间
+         */
+        _this.changedTime = undefined;
+        /**
+         * 分支名称
+         */
+        _this.branchName = undefined;
+        /**
+         * 合并代码相关
+         */
+        _this.workingCopy = undefined;
+        _this.branch = undefined;
+        /**
+         * 父节点
+         */
+        _this.parentNode = null;
+        _this.parentKey = '';
+        /**
+         * 是否正在编辑
+         * 前端 UI 状态
+         */
+        _this.editable = undefined;
+        /**
+         * 是否可以删除
+         * 前端 UI 状态
+         */
+        _this.removable = undefined;
+        /**
+         * 是否正在编辑
+         * 前端 UI 状态
+         */
+        _this.editing = false;
+        /**
+         * 是否正在请求
+         * 前端 UI 状态
+         */
+        _this.loading = false;
+        /**
+         * 节点是否为展开状态
+         * 前端 UI 状态
+         */
+        _this.expanded = false;
+        /**
+         * 节点是否显示
+         * 前端 UI 状态
+         */
+        _this.hidden = false;
+        /**
+         * 页面树节点是否显示
+         * 前端 UI 状态
+         */
+        _this.pageTreeNodeHidden = false;
+        /**
+         * 逻辑树节点是否显示
+         * 前端 UI 状态
+         */
+        _this.logicTreeNodeHidden = false;
+        /**
+         * 数据树节点是否显示
+         * 前端 UI 状态
+         */
+        _this.dataTreeNodeHidden = false;
+        /**
+         * 数据树节点是否展开
+         * 前端 UI 状态
+         */
+        _this.logicTreeNodeExpanded = false;
+        /**
+         * 用于挂 embeddedTS 的 sourceMap
+         */
+        _this.sourceMap = undefined;
+        /**
+         * 是否为叶子节点
+         * 前端 UI 状态
+         */
+        _this.isLeaf = false;
+        /**
+         * 当前节点上报错详细信息
+         */
+        _this.tsErrorDetail = undefined;
+        _this.name = '';
+        /**
+         * 是否正在编辑
+         * 前端 UI 状态
+         */
+        _this.__TypeAnnotation = undefined;
+        if (_this.hasOwnProperty('JSON_EXCLUDED_KEYS') && _this.JSON_EXCLUDED_KEYS === undefined)
+            delete _this.JSON_EXCLUDED_KEYS;
+        /**
+         * 监听action，delete，update事件
+         */
+        _this.on('create', _this.genActionListener);
+        _this.on('delete', _this.genActionListener);
+        _this.on('update', _this.genActionListener);
+        return _this;
+    }
+    BaseNode.prototype.subConstructor = function (source) {
+        var _this = this;
+        var propertyMap = decorators_1.getConceptPropertyMap(this.constructor.name);
+        var properties = Array.from(new Set(__spreadArrays(Object.keys(this), Object.keys(source)))).filter(function (key) { return propertyMap.has(key); });
+        properties.forEach(function (key) {
+            var property = propertyMap.get(key);
+            var sourceItem = source[key] !== undefined ? source[key] : _this[key];
+            var objectRefCtor;
+            try {
+                if (property.objectRef) {
+                    var arr = property.objectRef.split(' | ');
+                    for (var i = 0; i < arr.length; i++) {
+                        objectRefCtor = decorators_1.getConceptConstructor(arr[i]);
+                        if (sourceItem instanceof objectRefCtor) {
+                            sourceItem.parentNode = _this;
+                            sourceItem.parentKey = key;
+                            break;
+                        }
+                    }
+                }
+                // 数组的情况也在这里做掉了
+                _this[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;
+            }
+        });
+        // 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;
+        //             }));
+        // }
+    };
+    BaseNode.prototype.fixInstantiate = function () {
+        var _this = this;
+        var propertyMap = decorators_1.getConceptPropertyMap(this.constructor.name);
+        var properties = Object.keys(this).filter(function (key) { return propertyMap.has(key); });
+        properties.forEach(function (key) {
+            var property = propertyMap.get(key);
+            var sourceItem = _this[key];
+            var objectRefCtor = property.objectRef && decorators_1.getConceptConstructor(property.objectRef);
+            if (objectRefCtor) {
+                if (Array.isArray(sourceItem)) {
+                    sourceItem.forEach(function (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[key] = _this.instantiateSub(sourceItem instanceof BaseNode ? sourceItem.toJSON() : sourceItem, key);
+                    }
+                }
+            }
+        });
+    };
+    BaseNode.prototype.getIndexOfParent = function () {
+        var index = -1;
+        var parentNode = this.parentNode;
+        if (parentNode) {
+            var parentKey = this.parentKey;
+            var parentProperty = parentNode[parentKey];
+            if (Array.isArray(parentProperty)) {
+                index = parentProperty.indexOf(this);
+            }
+        }
+        return index;
+    };
+    /**
+     * 为存储点生成行为监听器
+     * @param action
+     * @returns
+     */
+    BaseNode.prototype.genActionListener = function ($event) {
+        var _a, _b;
+        // 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) {
+            var event = {
+                action: 'update',
+                path: (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.getNodePath(false),
+                object: {},
+                oldObject: {},
+                originEvent: $event.originEvent,
+                eventList: $event.eventList,
+                // eventStop为true后，数据不再存入eventList，就不再会将冒泡数据发送给后端
+                eventStop: true
+            };
+            (_b = this.parentNode) === null || _b === void 0 ? void 0 : _b.emit('update', event);
+        }
+    };
+    BaseNode.prototype.createNode = function (_a) {
+        var parentNode = _a.parentNode, parentKey = _a.parentKey, index = _a.index;
+        if (parentNode) {
+            var property_1 = parentNode[parentKey];
+            if (Array.isArray(property_1) && index !== -1) {
+                property_1.splice(index, 0, this);
+            }
+            else {
+                parentNode[parentKey] = this;
+            }
+            this.parentNode = parentNode;
+            this.parentKey = parentKey;
+            this.create({
+                index: index,
+                parentKey: parentKey
+            });
+        }
+    };
+    BaseNode.prototype.toTemplateJSON = function () {
+        return this._toJSON(function (source) {
+            delete source.id;
+            return source;
+        });
+    };
+    /**
+     * 创建节点
+     */
+    BaseNode.prototype.create = function (parentParams) {
+        this.emit('create', __assign(__assign({ action: 'create', path: this.getNodePath(true), object: this.toJSON() }, parentParams), { oldObject: null }));
+    };
+    /**
+     * 如果有父节点，则删除节点，在添加时调用
+     */
+    BaseNode.prototype.ensureDelete = function () {
+        var _a, _b;
+        var _c;
+        // 批量赋值因为连线的问题需要特殊处理一下.
+        if (((_c = this.parentNode) === null || _c === void 0 ? void 0 : _c.concept) === 'SelectMembers') {
+            this.parentNode.ensureDelete();
+            return;
+        }
+        if (this.parentNode && this.parentKey) {
+            var path = this.getNodePath(false);
+            var parentParams = this._delete();
+            if (parentParams && parentParams.index !== -1) {
+                if (Array.isArray(this.parentNode[this.parentKey])) {
+                    this.emit('delete', __assign({ action: 'delete', path: path, object: null }, parentParams));
+                }
+                else {
+                    var parentPath = this.parentNode.getNodePath(false);
+                    this.parentNode.emit('update', {
+                        action: 'update',
+                        path: parentPath,
+                        object: (_a = {},
+                            _a[this.parentKey] = null,
+                            _a),
+                        oldObject: (_b = {},
+                            _b[this.parentKey] = this.toJSON(),
+                            _b)
+                    });
+                }
+            }
+        }
+    };
+    /**
+     * 删除节点
+     */
+    BaseNode.prototype["delete"] = function () {
+        var _a, _b;
+        var _c, _d;
+        if (((_c = this.parentNode) === null || _c === void 0 ? void 0 : _c.concept) === 'Match' && this.parentKey === 'expression') {
+            this.parentNode.setExpressionWitchCase(null);
+            return;
+        }
+        // 批量赋值因为连线的问题需要特殊处理一下.
+        if (((_d = this.parentNode) === null || _d === void 0 ? void 0 : _d.concept) === 'SelectMembers') {
+            var node = this.parentNode;
+            node["delete"]();
+            return;
+        }
+        else if (this.concept === 'SelectMembers') {
+            var node = this.parentNode;
+            node.changeLinesLocation(this);
+        }
+        var useIndex = ['BindEvent', 'Identifier'].includes(this.concept);
+        var path = this.getNodePath(useIndex);
+        var parentParams = this._delete();
+        if (parentParams && parentParams.index !== -1) {
+            if (Array.isArray(this.parentNode[this.parentKey])) {
+                this.emit('delete', __assign({ action: 'delete', path: path, object: null }, parentParams));
+            }
+            else {
+                var parentPath = this.parentNode.getNodePath(false);
+                this.parentNode.emit('update', {
+                    action: 'update',
+                    path: parentPath,
+                    object: (_a = {},
+                        _a[this.parentKey] = null,
+                        _a),
+                    oldObject: (_b = {},
+                        _b[this.parentKey] = this.toJSON(),
+                        _b)
+                });
+            }
+        }
+    };
+    /**
+     * 更新节点
+     */
+    BaseNode.prototype.update = function (_a) {
+        var _this = this;
+        var _b, _c;
+        var field = _a.field, object = __rest(_a, ["field"]);
+        var path = this.getNodePath(false);
+        var oldObject = {};
+        var _loop_1 = function (key) {
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+                var oldProperty = (_b = this_1[key]) !== null && _b !== void 0 ? _b : null;
+                oldObject[key] = oldProperty;
+                if (Array.isArray(oldProperty)) {
+                    oldObject[key] = oldProperty.map(function (item) {
+                        var propertyItem = item !== null && item !== void 0 ? item : null;
+                        if (item instanceof BaseNode) {
+                            propertyItem = item.toJSON();
+                        }
+                        return propertyItem;
+                    });
+                }
+                else if (oldProperty instanceof BaseNode) {
+                    oldObject[key] = oldProperty.toJSON();
+                }
+                var property_2 = (_c = object[key]) !== null && _c !== void 0 ? _c : null;
+                this_1[key] = property_2;
+                var objectRefCtor = decorators_1.getConceptConstructor(property_2 === null || property_2 === void 0 ? void 0 : property_2.concept);
+                if (Array.isArray(property_2)) {
+                    this_1[key] = property_2.map(function (item) {
+                        var propertyItem = item !== null && item !== void 0 ? item : null;
+                        var propertyObjectRefCtor = decorators_1.getConceptConstructor(item === null || item === void 0 ? void 0 : item.concept);
+                        if (propertyObjectRefCtor === null || propertyObjectRefCtor === void 0 ? void 0 : propertyObjectRefCtor.from) {
+                            propertyItem = propertyObjectRefCtor.from(item, _this, key);
+                        }
+                        return propertyItem;
+                    });
+                }
+                else if (objectRefCtor === null || objectRefCtor === void 0 ? void 0 : objectRefCtor.from) {
+                    this_1[key] = objectRefCtor.from(property_2, this_1, key);
+                }
+            }
+        };
+        var this_1 = this;
+        for (var key in object) {
+            _loop_1(key);
+        }
+        this.emit('update', {
+            action: 'update',
+            path: path,
+            object: object,
+            oldObject: oldObject,
+            field: field
+        });
+    };
+    BaseNode.prototype._delete = function () {
+        /* override */
+        return {
+            propertyName: '',
+            index: -1,
+            object: null,
+            oldObject: this
+        };
+    };
+    BaseNode.from = function (source, parentNode, parentKey) {
+        // 有一些继承的情况
+        var Ctor = classMap_1["default"][source.concept] || this;
+        if (Ctor && source instanceof Ctor) {
+            if (parentNode) {
+                source.parentNode = parentNode;
+            }
+            if (parentKey) {
+                source.parentKey = parentKey;
+            }
+            return source;
+        }
+        if (Ctor) {
+            var instance = new Ctor();
+            if (parentNode) {
+                instance.parentNode = parentNode;
+            }
+            if (parentKey) {
+                instance.parentKey = parentKey;
+            }
+            instance.subConstructor(__assign(__assign({}, source), { concept: source.concept || Ctor.name, parentNode: parentNode }));
+            return instance;
+        }
+    };
+    Object.defineProperty(BaseNode.prototype, "nodePath", {
+        get: function () {
+            return this.getNodePath(false);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseNode.prototype.getNodePath = function (useIndex) {
+        var node = this;
+        var isNodeSelf = true;
+        var pathArr = [];
+        while (node) {
+            var path = '';
+            var parentNode = node.parentNode;
+            if (parentNode) {
+                var parentKey = node.parentKey;
+                path = parentKey;
+                var parentProperty = parentNode[parentKey];
+                if (Array.isArray(parentProperty)) {
+                    var name = node.name;
+                    if (!name || (useIndex && isNodeSelf)) {
+                        var index = parentProperty.indexOf(node);
+                        path += "[" + index + "]";
+                    }
+                    else {
+                        path += "[name=" + name + "]";
+                    }
+                }
+                pathArr.unshift(path);
+            }
+            node = parentNode;
+            isNodeSelf = false;
+        }
+        pathArr.unshift('app');
+        return pathArr.join('.');
+    };
+    Object.defineProperty(BaseNode.prototype, "upperNode", {
+        /**
+         * 上层节点
+         */
+        get: function () {
+            // eslint-disable-next-line consistent-this
+            var _upperNode = this;
+            while (!!_upperNode && _upperNode.concept === this.concept) {
+                _upperNode = _upperNode.parentNode;
+            }
+            return _upperNode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseNode.prototype, "rootNode", {
+        /**
+         * 根节点
+         */
+        get: function () {
+            return this.getAncestor('App');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * 获取祖先节点
+     */
+    BaseNode.prototype.getAncestor = function (concept) {
+        var upperNode = this.upperNode;
+        while (upperNode && upperNode.concept && upperNode.concept !== concept) {
+            upperNode = upperNode.upperNode;
+        }
+        return upperNode;
+    };
+    /**
+     *
+     * @param source
+     * @param Ctor
+     * @param completeList
+     * @param idsList
+     */
+    BaseNode.prototype.handleSource = function (source, completeList) {
+        var _a = source || {}, id = _a.id, concept = _a.concept;
+        var actualSource = source instanceof BaseNode ? source : map_1.getSourceFromMap(id, concept);
+        completeList.push(actualSource || source);
+    };
+    Object.defineProperty(BaseNode.prototype, "tsName", {
+        /**
+         * 获取当前的TsName
+         */
+        get: function () {
+            if (this.name) {
+                var tsName = this.name;
+                // 匹配所有特殊字符都转为_
+                tsName = tsName.replace(/\W/g, '_');
+                if (/^\d/.test(tsName)) {
+                    tsName = '$' + tsName;
+                }
+                return tsName;
+            }
+            return '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * 生成json
+     * @param instance
+     * @param Ctor
+     */
+    BaseNode.prototype.genSources = function (instance, filerFn) {
+        if (!instance) {
+            return instance;
+        }
+        if (Array.isArray(instance)) {
+            return instance.map(function (item) { return (item && item._toJSON ? item._toJSON(filerFn) : item); });
+        }
+        else {
+            return instance && instance._toJSON ? instance._toJSON(filerFn) : instance;
+        }
+    };
+    /**
+     * 实例化一个 JSON
+     * 由于有 from，只能先实例化父级，再实例化子级
+     * @param obj
+     * @param parentNode
+     * @returns
+     */
+    BaseNode.prototype.instantiate = function (source, parentNode, parentKey) {
+        if (source instanceof BaseNode) {
+            if (!source.parentNode || !source.parentKey) {
+                source.parentNode = parentNode;
+                source.parentKey = parentKey;
+            }
+            return source;
+        }
+        else if (source && source.concept && classMap_1["default"][source.concept]) {
+            var Ctor = classMap_1["default"][source.concept];
+            var instance = Ctor.from(source, parentNode, parentKey);
+            if (instance && instance.toStorageJSON)
+                instance.storageJSON = instance.toStorageJSON();
+            return instance;
+        }
+        else {
+            return source;
+        }
+    };
+    /**
+     * 激活 JSON 内部实例
+     * @param source
+     */
+    BaseNode.prototype.instantiateSub = function (source, parentKey) {
+        var _this = this;
+        if (!source) {
+            return;
+        }
+        var completeList = [];
+        var isArray = false;
+        // 暂时通过是否有name判断数据是否全
+        if (Array.isArray(source)) {
+            isArray = true;
+            source.forEach(function (sourceItem) {
+                _this.handleSource(sourceItem, completeList);
+            });
+        }
+        else {
+            this.handleSource(source, completeList);
+        }
+        var instanceList = completeList.map(function (item) { return _this.instantiate(item, _this, parentKey); });
+        if (isArray) {
+            return instanceList;
+        }
+        else if (Array.isArray(instanceList) && instanceList.length) {
+            return instanceList[0];
+        }
+    };
+    BaseNode.prototype.plainAssign = function (source) {
+        var _this = this;
+        this._mutable = true;
+        var oldId = this.id;
+        Object.keys(source).forEach(function (key) {
+            var value = source[key];
+            if (typeof value !== 'object' && typeof value !== 'function')
+                _this[key] = value;
+        });
+        this._mutable = false;
+    };
+    BaseNode.prototype.pick = function (source, keys) {
+        if (keys === void 0) { keys = []; }
+        var obj = {};
+        keys.forEach(function (key) { return (obj[key] = source[key]); });
+        // 这里统一用 assign，集中处理 id 的问题
+        // this.assign(obj);
+    };
+    /**
+     * 从对象中深度获取
+     * @param source
+     * @param keys
+     * @example 比如一般后端返回只是添加了个 id
+     * ```
+     * this.deepPick(result, ['id'])
+     */
+    BaseNode.prototype.deepPick = function (source, keys) {
+        var _this = this;
+        if (keys === void 0) { keys = []; }
+        utils.traverse(function (current) {
+            var subSource = current.jsonPath ? lodash_1.at(source, [current.jsonPath])[0] : source;
+            var target = current.jsonPath ? lodash_1.at(_this, [current.jsonPath])[0] : _this;
+            if (!target)
+                return;
+            var obj = {};
+            keys.forEach(function (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
+     */
+    BaseNode.prototype.toJSON = function () {
+        return this._toJSON();
+    };
+    BaseNode.prototype._toJSON = function (filerFn) {
+        var _this = this;
+        var propertyMap = decorators_1.getConceptPropertyMap(this.constructor.name);
+        var source = {};
+        propertyMap.forEach(function (property, key) {
+            if (property) {
+                var propertyObjectRef = property.objectRef;
+                if (!propertyObjectRef) {
+                    source[key] = _this[key];
+                }
+                else {
+                    var sources = _this.genSources(_this[key], filerFn);
+                    source[key] = sources;
+                }
+            }
+        });
+        return filerFn ? filerFn(source) : source;
+    };
+    /**
+     * 转为单层的 JSON
+     * @param parentKey 外面的 key，提供给 JSON.stringify 使用
+     * @param excludedKeys 需要额外排除的 keys
+     */
+    BaseNode.prototype.toPlainJSON = function (parentKey, excludedKeys) {
+        var _this = this;
+        if (excludedKeys === void 0) { excludedKeys = []; }
+        var JSON_EXCLUDED_KEYS = new Set(this.JSON_EXCLUDED_KEYS || []); // Object.getPrototypeOf(this).constructor.JSON_EXCLUDED_KEYS || [];
+        excludedKeys.forEach(function (key) { return JSON_EXCLUDED_KEYS.add(key); });
+        var temp = {};
+        Object.keys(this).forEach(function (key) {
+            var value = _this[key];
+            if (!JSON_EXCLUDED_KEYS.has(key) && typeof value !== 'object' && typeof value !== 'function')
+                temp[key] = value;
+        });
+        return JSON.parse(JSON.stringify(temp));
+    };
+    /**
+     * 查找引用
+     */
+    BaseNode.prototype.findUsage = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    BaseNode.prototype.findReadOnlyLogicUsage = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 重命名
+     */
+    BaseNode.prototype.changeName = function (newValue) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 准备删除
+     */
+    BaseNode.prototype.prepareDelete = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 添加参数准备
+     */
+    BaseNode.prototype.addParamsPrepare = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 获取当前节点类型
+     */
+    BaseNode.prototype.getCurrentTypeAnnotation = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 销毁
+     * 从 Map 中删除点和子节点
+     */
+    BaseNode.prototype.destroy = function () {
+        // utils.traverse((current) => , { node: this }, {
+        //     mode: 'anyObject',
+        //     excludedKeySet: this.JSON_EXCLUDED_KEYS,
+        // });
+    };
+    BaseNode.prototype.onChange = function ($event) {
+        /* override */
+    };
+    BaseNode.prototype.onCreate = function ($event) {
+        /* override */
+    };
+    BaseNode.prototype.onDelete = function ($event) {
+        /* override */
+    };
+    /**
+     * 移动节点
+     * @param sourceNode
+     * @param position
+     */
+    BaseNode.prototype.moveNode = function (options) {
+        var sourceNode = options.sourceNode, position = options.position;
+        if (this.concept === 'App') {
+            return;
+        }
+        var actionMsg = "\u79FB\u52A8" + this.constructor.nodeTitle;
+        if (this.name) {
+            actionMsg += "\u201C" + this.name + "\u201D";
+        }
+        sourceNode.app.emit('collect:start', {
+            actionMsg: actionMsg
+        });
+        // 如果是兄弟节点之前的移动
+        if (position !== 'append' && this.concept !== sourceNode.concept) {
+            return;
+        }
+        // 先删
+        this["delete"]();
+        if (position === 'append') {
+            var action_1 = options.action;
+            if (!action_1)
+                action_1 = "add" + this.concept;
+            var parentNode = sourceNode;
+            parentNode[action_1](this);
+        }
+        else {
+            var parentNode = sourceNode === null || sourceNode === void 0 ? void 0 : sourceNode.parentNode;
+            var parentKey = (sourceNode === null || sourceNode === void 0 ? void 0 : sourceNode.parentKey) || '';
+            var list = parentNode[parentKey];
+            if (Array.isArray(list)) {
+                var index = list.indexOf(sourceNode);
+                if (position === 'insertAfter') {
+                    index += 1;
+                }
+                Object.assign(this, {
+                    parentNode: parentNode,
+                    parentKey: parentKey
+                });
+                if (this.concept === 'ViewElement')
+                    this.name = this.getViewElementUniqueName(this.name);
+                list.splice(index, 0, this);
+                this.create({
+                    index: index,
+                    parentNode: parentNode,
+                    parentKey: parentKey
+                });
+            }
+        }
+        sourceNode.app.emit('collect:end');
+    };
+    /**
+     * 获取添加时的默认选项
+     * @returns
+     */
+    BaseNode.getDefaultOptions = function () {
+        return {};
+    };
+    BaseNode.prototype.traverseChildren = function (cb) {
+        function traverse(node) {
+            cb(node);
+            var propertyMap = decorators_1.getConceptPropertyMap(node === null || node === void 0 ? void 0 : node.concept);
+            if (!propertyMap)
+                return;
+            for (var _i = 0, _a = propertyMap.keys(); _i < _a.length; _i++) {
+                var property_3 = _a[_i];
+                var child = node[property_3];
+                if (!child)
+                    continue;
+                else if (Array.isArray(child))
+                    child.forEach(function (node) { return traverse(node); });
+                else
+                    traverse(child);
+            }
+        }
+        traverse(this);
+    };
+    /**
+     *  获取当前节点在nasl标注节点上的节点
+     */
+    BaseNode.prototype.getCurrentAnnotatedJSON = function () {
+        return this.__TypeAnnotation;
+    };
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    BaseNode.prototype.getCurrentSource = function () {
+        var node = this;
+        var sourceMap = node.sourceMap;
+        var fileNode = node;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (!sourceMap
+            && fileNode
+            && !(fileNode.parentNode instanceof __1.App)) {
+            fileNode = fileNode.parentNode;
+            sourceMap = fileNode === null || fileNode === void 0 ? void 0 : fileNode.sourceMap;
+        }
+        var currentSource = sourceMap && sourceMap.get(node);
+        if (currentSource) {
+            return { currentSource: currentSource, fileNode: fileNode };
+        }
+        return { fileNode: fileNode };
+    };
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    BaseNode.prototype.getFileConceptNode = function (concept) {
+        var node = this;
+        var sourceMap = node.sourceMap;
+        var fileNode = node;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (!sourceMap
+            && fileNode
+            && !(fileNode.parentNode instanceof __1.App)) {
+            fileNode = fileNode.parentNode;
+            sourceMap = fileNode === null || fileNode === void 0 ? void 0 : fileNode.sourceMap;
+        }
+        var arr = [];
+        sourceMap && sourceMap.forEach(function (value, key) {
+            if (key.concept === concept)
+                arr.push({ key: key, value: value });
+        });
+        return arr;
+    };
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "_mutable");
+    __decorate([
+        decorators_1.property()
+    ], BaseNode.prototype, "concept");
+    __decorate([
+        decorators_1.property()
+    ], BaseNode.prototype, "changedTime");
+    __decorate([
+        decorators_1.property()
+    ], BaseNode.prototype, "branchName");
+    __decorate([
+        decorators_1.property()
+    ], BaseNode.prototype, "workingCopy");
+    __decorate([
+        decorators_1.property()
+    ], BaseNode.prototype, "branch");
+    __decorate([
+        decorators_1.circular()
+    ], BaseNode.prototype, "parentNode");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "editable");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "removable");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "editing");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "loading");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "expanded");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "hidden");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "pageTreeNodeHidden");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "logicTreeNodeHidden");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "dataTreeNodeHidden");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "logicTreeNodeExpanded");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "sourceMap");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "isLeaf");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "storageJSON");
+    __decorate([
+        decorators_1.property()
+    ], BaseNode.prototype, "name");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], BaseNode.prototype, "__TypeAnnotation");
+    __decorate([
+        decorators_1.action('查找引用')
+    ], BaseNode.prototype, "findUsage");
+    __decorate([
+        decorators_1.action('重命名')
+    ], BaseNode.prototype, "changeName");
+    __decorate([
+        decorators_1.action('准备删除')
+    ], BaseNode.prototype, "prepareDelete");
+    __decorate([
+        decorators_1.action('添加参数准备')
+    ], BaseNode.prototype, "addParamsPrepare");
+    __decorate([
+        decorators_1.action('获取当前节点类型')
+    ], BaseNode.prototype, "getCurrentTypeAnnotation");
+    return BaseNode;
+}(EventEmitter_1.EventEmitter));
+exports.BaseNode = BaseNode;
+exports["default"] = BaseNode;