@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.3

package/out/common/BaseNode.js

@@ -0,0 +1,704 @@
+"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 config_1 = require("../config");
+const storage_1 = __importDefault(require("../service/storage"));
+const map_1 = require("../service/storage/map");
+const storagePoint_1 = require("../service/storage/storagePoint");
+const EventEmitter_1 = require("./EventEmitter");
+const utils = __importStar(require("../utils"));
+const classMap_1 = __importDefault(require("../common/classMap"));
+const decorators_1 = require("../decorators");
+/**
+ * 分割数组
+ * @param array 原数组
+ * @param subGroupLength 长度
+ * @returns
+ */
+function group(array, subGroupLength) {
+    let index = 0;
+    const newArray = [];
+    while (index < array.length) {
+        newArray.push(array.slice(index, (index += subGroupLength)));
+    }
+    return newArray;
+}
+/**
+ * 顶点类
+ * 属性均为只读，仅在初始化和 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;
+    /**
+     * 父节点
+     */
+    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);
+    }
+    async 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) => {
+            const property = propertyMap.get(key);
+            return !!property;
+        });
+        properties.forEach((key) => {
+            const property = propertyMap.get(key);
+            const sourceItem = source[key] || this[key];
+            const { objectRef: propertyObjectRef } = property;
+            let objectRefCtor;
+            if (propertyObjectRef) {
+                objectRefCtor = (0, decorators_1.getConceptConstructor)(propertyObjectRef);
+                if (objectRefCtor && sourceItem instanceof objectRefCtor) {
+                    if (!sourceItem.parentNode || !sourceItem.parentKey) {
+                        sourceItem.parentNode = this;
+                        sourceItem.parentKey = key;
+                    }
+                }
+            }
+            this[key] = objectRefCtor && !(sourceItem instanceof objectRefCtor) ? this.activeInside(sourceItem, objectRefCtor, this, key) : sourceItem;
+        });
+        if (config_1.config.storage.protocol === 'http' && storagePoint_1.loadThen[source.concept]) {
+            const { childNodes } = storagePoint_1.loadThen[source.concept] || {};
+            const queryList = childNodes.map(({ field, concept }) => {
+                const path = [this.nodePath, field].join('.');
+                return {
+                    path,
+                    excludes: storagePoint_1.loadThen[concept].childNodes.map(({ field }) => field),
+                };
+            });
+            const res = await storage_1.default.post('/api/storage/batchQuery', queryList, {
+                headers: {
+                    appId: this.rootNode?.id || this.id,
+                },
+            });
+            res?.data?.result.forEach((sourceItem, index) => {
+                const { field, concept } = childNodes[index];
+                if (!sourceItem || (Array.isArray(this[field]) && !Array.isArray(sourceItem))) {
+                    return;
+                }
+                const objectRefCtor = (0, decorators_1.getConceptConstructor)(concept);
+                this[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) {
+        this.onChange($event);
+        if (this.concept === 'App') {
+            this.emit('storage', $event);
+        }
+        else {
+            if (!$event.eventList) {
+                $event.eventList = [];
+            }
+            if (!$event.eventStop) {
+                $event.eventList.push($event);
+                if (['Process', 'View', 'Logic', 'Interface', 'Entity', 'Structure', 'Enum'].includes(this.concept)) {
+                    $event.eventStop = true;
+                }
+            }
+            const event = {
+                action: 'update',
+                path: this.parentNode?.getNodePath(false),
+                object: {},
+                oldObject: {},
+                originEvent: $event.originEvent || $event,
+                eventList: $event.eventList || [],
+            };
+            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,
+            ...parentParams,
+            oldObject: null,
+        });
+    }
+    /**
+     * 删除节点
+     */
+    delete() {
+        const path = this.getNodePath(false);
+        const parentParams = this._delete();
+        if (parentParams && parentParams.index !== -1) {
+            this.emit('delete', {
+                action: 'delete',
+                path,
+                object: null,
+                ...parentParams,
+            });
+        }
+    }
+    /**
+     * 更新节点
+     */
+    update({ field, ...object }) {
+        const path = this.getNodePath(false);
+        const oldObject = {};
+        for (const key in object) {
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+                oldObject[key] = this[key] ?? null;
+                this[key] = object[key] ?? null;
+            }
+        }
+        this.emit('update', {
+            action: 'update',
+            path,
+            object,
+            oldObject,
+        });
+    }
+    _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) {
+            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(isCreate) {
+        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 || (isCreate && 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);
+    }
+    /**
+     * 激活 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;
+        }
+        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 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 */
+    }
+    /**
+     * 获取添加时的默认选项
+     * @returns
+     */
+    static getDefaultOptions() {
+        return {};
+    }
+}
+__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.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