@lcap/nasl 1.0.0-alpha.8 → 1.0.1

package/src/concepts/Param__.ts

@@ -6,6 +6,7 @@ import Entity from './Entity__';
 import EntityProperty from './EntityProperty__';
 import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -243,7 +244,7 @@ export class Param extends BaseNode {
     @excludedInJSON()
     @property()
     useComponent: {
-        type: 's-member-identifier-select' | 's-enum-select' | 's-schema-select' | 's-datatype-select' | 's-options-select';
+        type: 's-member-identifier-select' | 's-enum-select' | 's-schema-select' | 's-datatype-select' | 's-config-select' | 's-options-select';
         attrs?: any;
     } = undefined;
 
@@ -254,7 +255,9 @@ export class Param extends BaseNode {
 
     toJS(state?: TranslatorState): string {
         if (this.view) {
-            return `${this.name} = ${this.name} !== undefined ? ${this.name} : this.$genInitFromSchema(${JSON.stringify(this.typeAnnotation)}, this.$route.query.hasOwnProperty('${this.name}') ? this.$route.query.${this.name} : ${JSON.stringify(this.defaultValue)}, true)`;
+            return `${this.name} = ${this.name} !== undefined ? ${this.name} : this.$genInitFromSchema(${JSON.stringify(this.typeAnnotation)}, this.$route.query.hasOwnProperty('${
+                this.name
+            }') ? this.$route.query.${this.name} : ${JSON.stringify(this.defaultValue)}, true)`;
         } else {
             return '';
         }
@@ -294,15 +297,20 @@ export class Param extends BaseNode {
                 // eslint-disable-next-line prefer-rest-params
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
         const object = {
             typeAnnotation,
-            // 处理下拉属性
-            completionChildren: this.getSelectRef(),
         };
+        try {
+            this.completionChildren = this.getSelectRef();
+        } catch (err) {
+            this.completionChildren = [];
+            console.log(err);
+        }
+        // 处理下拉属性
         return this.update({
             ...object,
         });
@@ -319,40 +327,58 @@ export class Param extends BaseNode {
         };
     }
 
+    _readonly: boolean = false;
     /**
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
+        return !!this.module || this._readonly;
     }
 
+    set readonly(val) {
+        this._readonly = val;
+    }
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        const moduleNames = typeNamespace.split('.');
-        let completionChildren;
-        if (typeKind === 'reference') {
-            let type: 'entities' | 'structures';
-            if (typeNamespace.endsWith('entities')) {
-                type = 'entities';
-            } else if (typeNamespace.endsWith('structures')) {
-                // 数据结构比较复杂，会有
-                type = 'structures';
-            }
-            // 内置模块
-            // if (typeNamespace.startsWith('nasl.')) {
-            // } else {
-            const data = this.app[type] as Array<Entity | Structure>;
-            if (data) {
-                const properties = data.find((item) => item.name === typeName)?.properties;
-                completionChildren = properties;
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
             } else {
                 completionChildren = undefined;
             }
-            // }
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/ProcessComponent__.ts

@@ -105,7 +105,7 @@ export class ProcessComponent extends BaseNode {
         return (this.attrs || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getAttributeUniqueName(name = 'attribute1') {
-        return utils.unique(name, this.getAttributeExistingNames());
+        return utils.unique(name, this.getAttributeExistingNames(), undefined, false);
     }
 
     /**
@@ -144,7 +144,7 @@ export class ProcessComponent extends BaseNode {
                 name: options,
             }, this, 'attrs');
         } else if (options instanceof Attribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             attribute = options;
             Object.assign(attribute, relationOptions);
         } else {
@@ -232,7 +232,7 @@ export class ProcessComponent extends BaseNode {
 
     addAttribute(options?: string | Partial<Attribute> | Attribute) {
         const node = this._addAttribute(options as any);
-        const index = this.attrs.length;
+        const index = this.attrs.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -247,7 +247,7 @@ export class ProcessComponent extends BaseNode {
         return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getLogicUniqueName(name = 'logic1') {
-        return utils.unique(name, this.getLogicExistingNames());
+        return utils.unique(name, this.getLogicExistingNames(), undefined, false);
     }
 
     /**
@@ -286,7 +286,7 @@ export class ProcessComponent extends BaseNode {
                 name: options,
             }, this, 'logics');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {
@@ -374,7 +374,7 @@ export class ProcessComponent extends BaseNode {
 
     addLogic(options?: string | Partial<Logic> | Logic) {
         const node = this._addLogic(options as any);
-        const index = this.logics.length;
+        const index = this.logics.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/ProcessElement__.ts

@@ -1,5 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
-import { constantToParam, genUserTaskLogic, returnToParam } from '../server/getProcesses';
+import { constantToParam, genUserTaskLogic, returnToParam, getPreviousTask, syncMemberExpression } from '../server/getProcesses';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -253,7 +253,7 @@ export class ProcessElement extends BaseNode {
         return (this.waypoints || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getPointUniqueName(name = 'point1') {
-        return utils.unique(name, this.getPointExistingNames());
+        return utils.unique(name, this.getPointExistingNames(), undefined, false);
     }
 
     /**
@@ -292,7 +292,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'waypoints');
         } else if (options instanceof Point) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             point = options;
             Object.assign(point, relationOptions);
         } else {
@@ -380,7 +380,7 @@ export class ProcessElement extends BaseNode {
 
     addPoint(options?: string | Partial<Point> | Point) {
         const node = this._addPoint(options as any);
-        const index = this.waypoints.length;
+        const index = this.waypoints.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -395,7 +395,7 @@ export class ProcessElement extends BaseNode {
         return (this.variables || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getVariableUniqueName(name = 'variable1') {
-        return utils.unique(name, this.getVariableExistingNames());
+        return utils.unique(name, this.getVariableExistingNames(), undefined, false);
     }
 
     /**
@@ -434,7 +434,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'variables');
         } else if (options instanceof Variable) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             variable = options;
             Object.assign(variable, relationOptions);
         } else {
@@ -522,7 +522,7 @@ export class ProcessElement extends BaseNode {
 
     addVariable(options?: string | Partial<Variable> | Variable) {
         const node = this._addVariable(options as any);
-        const index = this.variables.length;
+        const index = this.variables.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -537,7 +537,7 @@ export class ProcessElement extends BaseNode {
         return (this.returns || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getReturnUniqueName(name = 'ret1') {
-        return utils.unique(name, this.getReturnExistingNames());
+        return utils.unique(name, this.getReturnExistingNames(), undefined, false);
     }
 
     /**
@@ -576,7 +576,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -664,7 +664,7 @@ export class ProcessElement extends BaseNode {
 
     addReturn(options?: string | Partial<Return> | Return) {
         const node = this._addReturn(options as any);
-        const index = this.returns.length;
+        const index = this.returns.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -679,7 +679,7 @@ export class ProcessElement extends BaseNode {
         return (this.constants || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConstantUniqueName(name = 'constant1') {
-        return utils.unique(name, this.getConstantExistingNames());
+        return utils.unique(name, this.getConstantExistingNames(), undefined, false);
     }
 
     /**
@@ -718,7 +718,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'constants');
         } else if (options instanceof Constant) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             constant = options;
             Object.assign(constant, relationOptions);
         } else {
@@ -806,7 +806,7 @@ export class ProcessElement extends BaseNode {
 
     addConstant(options?: string | Partial<Constant> | Constant) {
         const node = this._addConstant(options as any);
-        const index = this.constants.length;
+        const index = this.constants.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -821,7 +821,7 @@ export class ProcessElement extends BaseNode {
         return (this.bindAttrs || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getBindAttributeUniqueName(name = 'bindAttribute1') {
-        return utils.unique(name, this.getBindAttributeExistingNames());
+        return utils.unique(name, this.getBindAttributeExistingNames(), undefined, false);
     }
 
     /**
@@ -860,7 +860,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'bindAttrs');
         } else if (options instanceof BindAttribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             bindAttribute = options;
             Object.assign(bindAttribute, relationOptions);
         } else {
@@ -948,7 +948,7 @@ export class ProcessElement extends BaseNode {
 
     addBindAttribute(options?: string | Partial<BindAttribute> | BindAttribute) {
         const node = this._addBindAttribute(options as any);
-        const index = this.bindAttrs.length;
+        const index = this.bindAttrs.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -1328,23 +1328,86 @@ export class ProcessElement extends BaseNode {
     toEmbeddedTS(state?: TranslatorState): string {
         // this.syncLogic();
         const tab0 = indent(state.tabSize);
-        let code = '';
+        const tab1 = indent(state.tabSize + 1);
+        const tab3 = indent(state.tabSize + 2);
+        const tab4 = indent(state.tabSize + 3);
+        const tab5 = indent(state.tabSize + 4);
+        const tab6 = indent(state.tabSize + 5);
+        let code = `${this.name}: {\n`;
         this.variables.forEach((property) => {
-            code += `${tab0}let `;
-            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += `${tab1}`;
+            code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
         });
-
         this.returns.forEach((property) => {
-            code += `${tab0}let `;
-            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += `${tab1}`;
+            code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
         });
         this.constants.forEach((property) => {
-            code += `${tab0}export let `;
-            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += `${tab1}`;
+            code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
         });
+
+        if (this.type === 'UserTask'
+            || this.type === 'ExclusiveGateway') {
+            const prevTasks = getPreviousTask(this);
+            let prevCode = `${tab3}const ${this.process.name} = {\n`;
+            const processName = this.process.name;
+            this.process.params.forEach((p) => {
+                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
+            });
+            this.process.returns.forEach((p) => {
+                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
+            });
+            this.process.constants.forEach((p) => {
+                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
+            });
+            // prevCode += `${tab4}elements: {\n`
+            prevCode += prevTasks.map((t) => `${tab5}${t.name}: elements.${t.name},\n`).join(``);
+
+            // prevCode += `${tab4}}\n`
+
+            if (this.type === 'UserTask') {
+                prevCode += `\n${tab5}${this.name}: { \n${this.constants.map((c) => `${tab6}${c.name}: "",`).join('\n')} }\n`;
+                prevCode += `${tab3}}\n`;
+                code += `${tab1}logics: {\n`;
+                this.bindAttrs.forEach((attr) => {
+                    if (attr.name === 'destination') {
+                        code += `${attr.destination.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode)},\n`;
+                    }
+                });
+                const logic = genUserTaskLogic(this);
+                // sourceMap 映射
+                logic.parentNode = this.process;
+
+                code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }));
+                code += ',\n';
+                code += `${tab1}}`;
+            }
+
+            if (this.type === 'ExclusiveGateway') {
+                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`;
+                prevCode += `${tab3}}\n`;
+                code += `${tab1}logic: ${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode, true)},`;
+            }
+        }
+        code += `${tab0}\n},`;
+        // let code = '';
+        // this.variables.forEach((property) => {
+        //     code += `${tab0}export let `;
+        //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     code += ';\n';
+        // });
+
+        // this.returns.forEach((property) => {
+        //     code += `${tab0}export let `;
+        //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     code += ';\n';
+        // });
+        // this.constants.forEach((property) => {
+        //     code += `${tab0}export let `;
+        //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     code += ';\n';
+        // });
         return code;
     }
 
@@ -1362,23 +1425,23 @@ export class ProcessElement extends BaseNode {
     /**
      * 设置流程元素名称
      */
-    setNameWithFlowChange(name: string) {
-        this.app.emit('collect:start', {
-            actionMsg: '设置流程元素名称',
-        });
-        const oldName = this.name;
-        this.setName(name);
-        const process = this.process;
-        process.elements.forEach((el) => {
-            if (el.sourceRef === oldName) {
-                el.setSourceRef(name);
-            }
-            if (el.targetRef === oldName) {
-                el.setTargetRef(name);
-            }
-        });
-        this.app.emit('collect:end');
-    }
+    // setNameWithFlowChange(name: string) {
+    //     this.app.emit('collect:start', {
+    //         actionMsg: '设置流程元素名称',
+    //     });
+    //     const oldName = this.name;
+    //     this.setName(name);
+    //     const process = this.process;
+    //     process.elements.forEach((el) => {
+    //         if (el.sourceRef === oldName) {
+    //             el.setSourceRef(name);
+    //         }
+    //         if (el.targetRef === oldName) {
+    //             el.setTargetRef(name);
+    //         }
+    //     });
+    //     this.app.emit('collect:end');
+    // }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1391,3 +1454,39 @@ export default ProcessElement;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
+ProcessElement.prototype.setName = function (name: string) {
+    const App = this.rootNode;
+    const oldName = this.name;
+    const processName = this.parentNode.name;
+
+    App.emit('collect:start', {
+        actionMsg: '设置名称',
+    });
+    const object = {
+        name,
+    };
+    this.update({
+        ...object,
+        field: 'name',
+    });
+    syncMemberExpression(this, (node) => {
+        if (node.object.name === processName && node.property.name === oldName) {
+            node.property.update({
+                name,
+            });
+        }
+    });
+    const process = this.process;
+    process.elements.forEach((el) => {
+        if (el.sourceRef === oldName) {
+            el.setSourceRef(name);
+        }
+        if (el.targetRef === oldName) {
+            el.setTargetRef(name);
+        }
+    });
+    if (this.logic) {
+        this.logic.setName(name);
+    }
+    App.emit('collect:end');
+};

package/src/concepts/ProcessOutcome__.ts

@@ -74,7 +74,7 @@ export class ProcessOutcome extends LogicItem {
     //================================================================================
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        const code = `return () => ${this.flowRef && `"${this.flowRef}"`}`;
+        const code = `return () => ${this.flowRef ? `"${this.flowRef}"` : '__IDENTIFIER__'}`;
         return code;
     }