@lcap/nasl 2.13.0-beta → 2.13.0-beta.1

package/out/common/BaseNode.js

@@ -0,0 +1,891 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNode = void 0;
+const lodash_1 = require("lodash");
+const uuid_1 = require("uuid");
+const map_1 = require("../service/storage/map");
+const EventEmitter_1 = require("./EventEmitter");
+const utils = __importStar(require("../utils"));
+const classMap_1 = __importDefault(require("../common/classMap"));
+const decorators_1 = require("../decorators");
+/**
+ * 顶点类
+ * 属性均为只读，仅在初始化和 load 的情况下可以修改
+ */
+class BaseNode extends EventEmitter_1.EventEmitter {
+    /**
+     * 可修改标志，内部属性
+     * 标记在构造函数结束后是否可修改
+     */
+    _mutable = true;
+    /**
+     * 概念
+     */
+    concept = undefined;
+    /**
+     * toJSON 时需要去除的键，为了避免出现 CircularJSON
+     */
+    JSON_EXCLUDED_KEYS;
+    /**
+     * 唯一 Id
+     */
+    id = (0, uuid_1.v4)().replace(/-/g, '');
+    /**
+     * 变动时间
+     */
+    changedTime = undefined;
+    /**
+     * 分支名称
+     */
+    branchName = undefined;
+    /**
+     * 合并代码相关
+     */
+    workingCopy = undefined;
+    branch = undefined;
+    /**
+     * 父节点
+     */
+    parentNode = null;
+    parentKey = '';
+    /**
+     * 是否正在编辑
+     * 前端 UI 状态
+     */
+    editable = undefined;
+    /**
+     * 是否可以删除
+     * 前端 UI 状态
+     */
+    removable = undefined;
+    /**
+     * 是否正在编辑
+     * 前端 UI 状态
+     */
+    editing = false;
+    /**
+     * 是否正在请求
+     * 前端 UI 状态
+     */
+    loading = false;
+    /**
+     * 节点是否为展开状态
+     * 前端 UI 状态
+     */
+    expanded = false;
+    /**
+     * 节点是否显示
+     * 前端 UI 状态
+     */
+    hidden = false;
+    /**
+     * 页面树节点是否显示
+     * 前端 UI 状态
+     */
+    pageTreeNodeHidden = false;
+    /**
+     * 逻辑树节点是否显示
+     * 前端 UI 状态
+     */
+    logicTreeNodeHidden = false;
+    /**
+     * 数据树节点是否显示
+     * 前端 UI 状态
+     */
+    dataTreeNodeHidden = false;
+    /**
+     * 数据树节点是否展开
+     * 前端 UI 状态
+     */
+    logicTreeNodeExpanded = false;
+    /**
+     * 用于挂 embeddedTS 的 sourceMap
+     */
+    sourceMap = undefined;
+    /**
+     * 是否为叶子节点
+     * 前端 UI 状态
+     */
+    isLeaf = false;
+    storageJSON;
+    /**
+     * 当前节点上报错详细信息
+     */
+    tsErrorDetail = undefined;
+    name = '';
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        super();
+        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);
+    }
+    subConstructor(source) {
+        const propertyMap = (0, decorators_1.getConceptPropertyMap)(this.constructor.name);
+        const properties = Array.from(new Set([...Object.keys(this), ...Object.keys(source)])).filter((key) => propertyMap.has(key));
+        properties.forEach((key) => {
+            const property = propertyMap.get(key);
+            const sourceItem = source[key] !== undefined ? source[key] : this[key];
+            const { objectRef: propertyObjectRef } = property;
+            let objectRefCtor;
+            try {
+                if (propertyObjectRef) {
+                    objectRefCtor = (0, decorators_1.getConceptConstructor)(propertyObjectRef);
+                    if (objectRefCtor) {
+                        // if (Array.isArray(sourceItem)) {
+                        //     sourceItem.forEach((item) => {
+                        //         if (item instanceof objectRefCtor) {
+                        //             item.parentNode = this;
+                        //             item.parentKey = key;
+                        //         }
+                        //     });
+                        // } else
+                        if (sourceItem instanceof objectRefCtor) {
+                            sourceItem.parentNode = this;
+                            sourceItem.parentKey = key;
+                        }
+                    }
+                }
+                this[key] = objectRefCtor && sourceItem && !(sourceItem instanceof objectRefCtor) ? this.activeInside(sourceItem, objectRefCtor, this, 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.activeInside(sourceItem, objectRefCtor, this, field) : sourceItem;
+        //             }));
+        // }
+    }
+    getIndexOfParent() {
+        let index = -1;
+        const parentNode = this.parentNode;
+        if (parentNode) {
+            const parentKey = this.parentKey;
+            const parentProperty = parentNode[parentKey];
+            if (Array.isArray(parentProperty)) {
+                index = parentProperty.indexOf(this);
+            }
+        }
+        return index;
+    }
+    /**
+     * 为存储点生成行为监听器
+     * @param action
+     * @returns
+     */
+    genActionListener($event) {
+        if (!$event.eventList) {
+            $event.eventList = [];
+        }
+        if (!$event.eventStop) {
+            $event.eventList.push($event);
+            // 页面逻辑需要冒泡到页面
+            if (['App', 'Process', 'View', 'Interface', 'Entity', 'Structure', 'Enum', 'ConfigProperty'].includes(this.concept) || (this.concept === 'Logic' && !(this.getAncestor('View') || this.getAncestor('Process')))) {
+                $event.eventStop = true;
+            }
+        }
+        $event.originEvent = $event.originEvent || $event;
+        this.onChange($event);
+        if (this.concept === 'App') {
+            this.emit('storage', $event);
+        }
+        else {
+            const event = {
+                action: 'update',
+                path: this.parentNode?.getNodePath(false),
+                object: {},
+                oldObject: {},
+                originEvent: $event.originEvent,
+                eventList: $event.eventList,
+                eventStop: $event.eventStop,
+            };
+            this.parentNode?.emit('update', event);
+        }
+    }
+    createNode({ parentNode, parentKey, index }) {
+        if (parentNode) {
+            const property = parentNode[parentKey];
+            if (Array.isArray(property) && index !== -1) {
+                property.splice(index, 0, this);
+            }
+            else {
+                parentNode[parentKey] = this;
+            }
+            this.parentNode = parentNode;
+            this.parentKey = parentKey;
+            this.create({
+                index,
+                parentKey,
+            });
+        }
+    }
+    toTemplateJSON() {
+        return this._toJSON((source) => {
+            delete source.id;
+            return source;
+        });
+    }
+    /**
+     * 创建节点
+     */
+    create(parentParams) {
+        this.emit('create', {
+            action: 'create',
+            path: this.getNodePath(true),
+            object: this.toJSON(),
+            ...parentParams,
+            oldObject: null,
+        });
+    }
+    /**
+     * 如果有父节点，则删除节点，在添加时调用
+     */
+    ensureDelete() {
+        if (this.parentNode && this.parentKey) {
+            const path = this.getNodePath(false);
+            const parentParams = this._delete();
+            if (parentParams && parentParams.index !== -1) {
+                if (Array.isArray(this.parentNode[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(),
+                        },
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * 删除节点
+     */
+    delete() {
+        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[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(),
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * 更新节点
+     */
+    update({ field, ...object }) {
+        const path = this.getNodePath(false);
+        const oldObject = {};
+        for (const key in object) {
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+                const oldProperty = this[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[key] = property;
+                const objectRefCtor = (0, decorators_1.getConceptConstructor)(property?.concept);
+                if (Array.isArray(property)) {
+                    this[key] = property.map((item) => {
+                        let propertyItem = item ?? null;
+                        const propertyObjectRefCtor = (0, decorators_1.getConceptConstructor)(item?.concept);
+                        if (propertyObjectRefCtor?.from) {
+                            propertyItem = propertyObjectRefCtor.from(item, this, key);
+                        }
+                        return propertyItem;
+                    });
+                }
+                else if (objectRefCtor?.from) {
+                    this[key] = objectRefCtor.from(property, this, key);
+                }
+            }
+        }
+        this.emit('update', {
+            action: 'update',
+            path,
+            object,
+            oldObject,
+            field,
+        });
+    }
+    _delete() {
+        /* override */
+        return {
+            propertyName: '',
+            index: -1,
+            object: null,
+            oldObject: this,
+        };
+    }
+    static from(source, parentNode, parentKey) {
+        // 有一些继承的情况
+        const 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) {
+            const instance = new Ctor();
+            if (parentNode) {
+                instance.parentNode = parentNode;
+            }
+            if (parentKey) {
+                instance.parentKey = parentKey;
+            }
+            instance.subConstructor({
+                ...source,
+                concept: source.concept || Ctor.name,
+                parentNode,
+            });
+            return instance;
+        }
+    }
+    get nodePath() {
+        return this.getNodePath(false);
+    }
+    getNodePath(useIndex) {
+        let node = this;
+        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];
+                if (Array.isArray(parentProperty)) {
+                    const name = node.name;
+                    if (!name || (useIndex && isNodeSelf)) {
+                        const index = parentProperty.indexOf(node);
+                        path += `[${index}]`;
+                    }
+                    else {
+                        path += `[name=${name}]`;
+                    }
+                }
+                pathArr.unshift(path);
+            }
+            node = parentNode;
+            isNodeSelf = false;
+        }
+        pathArr.unshift('app');
+        return pathArr.join('.');
+    }
+    /**
+     * 上层节点
+     */
+    get upperNode() {
+        // eslint-disable-next-line consistent-this
+        let _upperNode = this;
+        while (!!_upperNode && _upperNode.concept === this.concept) {
+            _upperNode = _upperNode.parentNode;
+        }
+        return _upperNode;
+    }
+    /**
+     * 根节点
+     */
+    get rootNode() {
+        return this.getAncestor('App');
+    }
+    /**
+     * 获取祖先节点
+     */
+    getAncestor(concept) {
+        let upperNode = this.upperNode;
+        while (upperNode && upperNode.concept && upperNode.concept !== concept) {
+            upperNode = upperNode.upperNode;
+        }
+        return upperNode;
+    }
+    /**
+     *
+     * @param source
+     * @param Ctor
+     * @param completeList
+     * @param idsList
+     */
+    handleSource(source, completeList) {
+        const { id, concept } = source || {};
+        const actualSource = source instanceof BaseNode ? source : (0, map_1.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;
+        }
+        return '';
+    }
+    /**
+     * 激活 JSON 内部实例
+     * @param source
+     */
+    activeInside(source, Ctor, parentNode, parentKey) {
+        if (!source) {
+            return;
+        }
+        const completeList = [];
+        let isArray = false;
+        // 暂时通过是否有name判断数据是否全
+        if (Array.isArray(source)) {
+            isArray = true;
+            source.forEach((sourceItem) => {
+                this.handleSource(sourceItem, completeList);
+            });
+        }
+        else {
+            this.handleSource(source, completeList);
+        }
+        const instanceList = completeList.map((item) => this.instantiate(item, this, parentKey));
+        if (isArray) {
+            return instanceList;
+        }
+        else if (Array.isArray(instanceList) && instanceList.length) {
+            return instanceList[0];
+        }
+    }
+    /**
+     * 生成json
+     * @param instance
+     * @param Ctor
+     */
+    genSources(instance, filerFn) {
+        if (!instance) {
+            return instance;
+        }
+        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, 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]) {
+            const Ctor = classMap_1.default[source.concept];
+            const instance = Ctor.from(source, parentNode, parentKey);
+            if (instance && instance.toStorageJSON)
+                instance.storageJSON = instance.toStorageJSON();
+            return instance;
+        }
+        else {
+            return source;
+        }
+    }
+    plainAssign(source) {
+        this._mutable = true;
+        const oldId = this.id;
+        Object.keys(source).forEach((key) => {
+            const value = source[key];
+            if (typeof value !== 'object' && typeof value !== 'function')
+                this[key] = value;
+        });
+        this._mutable = false;
+    }
+    pick(source, keys = []) {
+        const obj = {};
+        keys.forEach((key) => (obj[key] = source[key]));
+        // 这里统一用 assign，集中处理 id 的问题
+        // this.assign(obj);
+    }
+    /**
+     * 从对象中深度获取
+     * @param source
+     * @param keys
+     * @example 比如一般后端返回只是添加了个 id
+     * ```
+     * this.deepPick(result, ['id'])
+     */
+    deepPick(source, keys = []) {
+        utils.traverse((current) => {
+            const subSource = current.jsonPath ? (0, lodash_1.at)(source, [current.jsonPath])[0] : source;
+            const target = current.jsonPath ? (0, lodash_1.at)(this, [current.jsonPath])[0] : this;
+            if (!target)
+                return;
+            const obj = {};
+            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) {
+        const propertyMap = (0, decorators_1.getConceptPropertyMap)(this.constructor.name);
+        const source = {};
+        propertyMap.forEach((property, key) => {
+            if (property) {
+                const { objectRef: propertyObjectRef } = property;
+                if (!propertyObjectRef) {
+                    source[key] = this[key];
+                }
+                else {
+                    const sources = this.genSources(this[key], filerFn);
+                    source[key] = sources;
+                }
+            }
+        });
+        return filerFn ? filerFn(source) : source;
+    }
+    /**
+     * 转为单层的 JSON
+     * @param parentKey 外面的 key，提供给 JSON.stringify 使用
+     * @param excludedKeys 需要额外排除的 keys
+     */
+    toPlainJSON(parentKey, excludedKeys = []) {
+        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 = {};
+        Object.keys(this).forEach((key) => {
+            const value = this[key];
+            if (!JSON_EXCLUDED_KEYS.has(key) && typeof value !== 'object' && typeof value !== 'function')
+                temp[key] = value;
+        });
+        return JSON.parse(JSON.stringify(temp));
+    }
+    /**
+     * 查找引用
+     */
+    async findUsage() {
+        /* override */
+    }
+    async findReadOnlyLogicUsage() {
+        /* override */
+    }
+    /**
+     * 重命名
+     */
+    async changeName(newValue) {
+        /* override */
+    }
+    /**
+     * 准备删除
+     */
+    async prepareDelete() {
+        /* override */
+    }
+    /**
+     * 添加参数准备
+     */
+    async addParamsPrepare() {
+        /* override */
+    }
+    /**
+     * 销毁
+     * 从 Map 中删除点和子节点
+     */
+    destroy() {
+        // utils.traverse((current) => , { node: this }, {
+        //     mode: 'anyObject',
+        //     excludedKeySet: this.JSON_EXCLUDED_KEYS,
+        // });
+    }
+    onChange($event) {
+        /* override */
+    }
+    onCreate($event) {
+        /* override */
+    }
+    onDelete($event) {
+        /* override */
+    }
+    /**
+     * 移动节点
+     * @param sourceNode
+     * @param position
+     */
+    moveNode(options) {
+        const { sourceNode, position } = options;
+        if (this.concept === 'App') {
+            return;
+        }
+        let actionMsg = `移动${this.constructor.nodeTitle}`;
+        if (this.name) {
+            actionMsg += `“${this.name}”`;
+        }
+        sourceNode.app.emit('collect:start', {
+            actionMsg,
+        });
+        // 如果是兄弟节点之前的移动
+        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[action](this);
+        }
+        else {
+            const parentNode = sourceNode?.parentNode;
+            const parentKey = sourceNode?.parentKey || '';
+            const list = parentNode[parentKey];
+            if (Array.isArray(list)) {
+                let index = list.indexOf(sourceNode);
+                if (position === 'insertAfter') {
+                    index += 1;
+                }
+                Object.assign(this, {
+                    parentNode,
+                    parentKey,
+                });
+                list.splice(index, 0, this);
+                this.create({
+                    index,
+                    parentNode,
+                    parentKey,
+                });
+            }
+        }
+        sourceNode.app.emit('collect:end');
+    }
+    /**
+     * 获取添加时的默认选项
+     * @returns
+     */
+    static getDefaultOptions() {
+        return {};
+    }
+    traverseChildren(cb) {
+        function traverse(node) {
+            cb(node);
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node.concept);
+            if (!propertyMap)
+                return;
+            for (const property of propertyMap.keys()) {
+                const child = node[property];
+                if (!child)
+                    continue;
+                else if (Array.isArray(child))
+                    child.forEach((node) => traverse(node));
+                else
+                    traverse(child);
+            }
+        }
+        traverse(this);
+    }
+}
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "_mutable", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "concept", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "changedTime", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "branchName", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "workingCopy", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "branch", void 0);
+__decorate([
+    (0, decorators_1.circular)()
+], BaseNode.prototype, "parentNode", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "editable", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "removable", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "editing", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "loading", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "expanded", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "hidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "pageTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "logicTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "dataTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "logicTreeNodeExpanded", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "sourceMap", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "isLeaf", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "storageJSON", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "name", void 0);
+__decorate([
+    (0, decorators_1.action)('查找引用')
+], BaseNode.prototype, "findUsage", null);
+__decorate([
+    (0, decorators_1.action)('重命名')
+], BaseNode.prototype, "changeName", null);
+__decorate([
+    (0, decorators_1.action)('准备删除')
+], BaseNode.prototype, "prepareDelete", null);
+__decorate([
+    (0, decorators_1.action)('添加参数准备')
+], BaseNode.prototype, "addParamsPrepare", null);
+exports.BaseNode = BaseNode;
+exports.default = BaseNode;
+//# sourceMappingURL=BaseNode.js.map