@lcap/nasl 2.18.0 → 2.19.0-beta.2

package/src/concepts/ProcessOutcomes__.ts

@@ -0,0 +1,90 @@
+import { TranslatorState, withSourceMap } from '../translator';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import LogicItem from './LogicItem__';
+
+/**
+ * 判断结果数组
+ */
+@concept('判断结果数组')
+export class ProcessOutcomes extends LogicItem {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'ProcessOutcomes' = 'ProcessOutcomes';
+
+    /**
+     * 判断结果数组标题
+     */
+    @property()
+    label: string = '流向';
+
+    /**
+     * 关联连接器
+     */
+    @property()
+    flowRefs: Array<string> = [];
+
+    
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ProcessOutcomes>) {
+        source = Object.assign({}, ProcessOutcomes.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): ProcessOutcomes {
+        return super.from(source, parentNode, parentKey) as ProcessOutcomes;
+    }
+
+    
+    /**
+     * 设置关联连接器
+     */
+    setFlowRefs(flowRefs: Array<string>) {
+        const object = {
+            flowRefs,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    
+
+    
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        const code = `return () => ${this.flowRefs?.length > 0 ? `"${this.flowRefs}"` : '__IDENTIFIER__'}`;
+        return code;
+    }
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap.ProcessOutcomes = ProcessOutcomes;
+export default ProcessOutcomes;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/Return__.ts

@@ -238,7 +238,10 @@ export class Return extends BaseNode {
     toJS(state?: TranslatorState): string {
         const context = this.view ? 'this' : 'Vue.prototype';
         const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
-        const needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
+        const needGenInitFromSchema = typeAnnotation && (
+            !['primitive', 'union'].includes(typeAnnotation.typeKind) 
+            || typeAnnotation.typeName === 'DateTime'
+        );
         let code = `${this.name} =`;
         if (needGenInitFromSchema) {
             code += `${context}.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;

package/src/concepts/SelectMembers__.ts

@@ -332,11 +332,11 @@ export class SelectMembers extends BaseNode {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
     get lines() {
-        const batchAssignment: any = this.getAncestor('BatchAssignment');
+        const rootNode: any = this.getAncestor('NewComposite') || this.getAncestor('BatchAssignment');
         const parentKey = this.parentKey;
-        const firstIndex = parentKey === 'left' ? 0 : batchAssignment.rights.findIndex((selectMember: SelectMembers) => selectMember === this);
+        const firstIndex = parentKey === 'left' ? 0 : rootNode.rights.findIndex((selectMember: SelectMembers) => selectMember === this);
         let count = 0;
-        batchAssignment.assignmentLines.forEach((line: AssignmentLine) => {
+        rootNode.assignmentLines.forEach((line: AssignmentLine) => {
             const lineIndex = parentKey === 'left' ? line.leftIndex[0] : line.rightIndex[0];
             if (lineIndex === firstIndex)
                 count++;

package/src/concepts/StringInterpolation__.ts

@@ -30,7 +30,7 @@ export class StringInterpolation extends LogicItem {
     @property('LogicItem')
     expressions: Array<LogicItem> = [];
 
-    
+
 
     /**
      * @param source 需要合并的部分参数
@@ -45,7 +45,7 @@ export class StringInterpolation extends LogicItem {
         return super.from(source, parentNode, parentKey) as StringInterpolation;
     }
 
-    
+
     /**
      * 设置插值表达式
      */
@@ -58,7 +58,7 @@ export class StringInterpolation extends LogicItem {
         });
     }
 
-        getItemExistingNames(excludedList: Array<LogicItem> = []) {
+    getItemExistingNames(excludedList: Array<LogicItem> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.expressions as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -200,7 +200,7 @@ export class StringInterpolation extends LogicItem {
     }
 
 
-    
+
 
     /**
     * 删除逻辑项
@@ -257,7 +257,7 @@ export class StringInterpolation extends LogicItem {
 
     exchangeLogicItem(target: LogicItem, logicitem: LogicItem) {
         const idx = this.expressions.findIndex(exp => exp === target);
-        if(idx !== -1) {
+        if (idx !== -1) {
             const exps = this.expressions.slice();
             exps.splice(idx, 1, logicitem);
             this.setExpressions(exps);
@@ -265,29 +265,39 @@ export class StringInterpolation extends LogicItem {
     }
 
     toVue(options?: ElementToVueOptions): string {
-        return this.expressions.map(exp => exp.toVue(options)).join(' + ');
+        return this.expressions.map((exp: any) => {
+            let expCode = exp.toVue();
+            if (options.finalCode !== false) {
+                const expTypeAnnotation = exp.typeAnnotation || exp.__TypeAnnotation;
+                expCode =  `$utils['ToString'](${expCode}, '${expTypeAnnotation?.sortedTypeKey}')`;
+            }
+            return expCode;
+        }).join(' + ');
     }
     toUI(): string {
         return this.expressions.map(exp => exp.toUI()).join(' + ');
     }
 
     toJS(): string {
-        return this.expressions.map(exp => exp.toJS()).join(' + ');
+        return this.expressions.map((exp: any) => {
+            const expTypeAnnotation = exp.typeAnnotation || exp.__TypeAnnotation;
+            return `this.$utils['ToString'](${exp.toJS()}, '${expTypeAnnotation?.sortedTypeKey}')`;
+        }).join(' + ');
     }
 
-    toBrief(): string { 
+    toBrief(): string {
         return this.expressions.map(exp => exp.toJS()).join(' + ');
     }
-    
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = 'nasl.util.stringInterpolation(';
         this.expressions.forEach((exp, idx) => {
             code += exp.toEmbeddedTS(shiftState(state, code));
-            if(idx !== this.expressions.length - 1){
+            if (idx !== this.expressions.length - 1) {
                 code += ', ';
             }
-            
+
         });
         code += ')\n';
         return code;

package/src/concepts/TypeAnnotation__.ts

@@ -121,8 +121,6 @@ export class TypeAnnotation extends BaseNode {
     @property()
     ruleMap: Object = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -159,10 +157,6 @@ export class TypeAnnotation extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入类型标注
     * @internal
@@ -195,8 +189,6 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -219,8 +211,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
@@ -240,8 +230,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -265,8 +253,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
     * 插入类型标注
     * @internal
@@ -299,8 +285,6 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -323,8 +307,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
@@ -344,8 +326,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationInReturnTypeAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -369,11 +349,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-
-
-
-    
-
     /**
     * 插入数据结构属性
     * @internal
@@ -406,8 +381,6 @@ export class TypeAnnotation extends BaseNode {
         return structureProperty;
     }
 
-    
-
     /**
      * 插入数据结构属性
      * @param structurePropertyOptions 数据结构属性参数
@@ -430,8 +403,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加数据结构属性
      * @internal
@@ -451,8 +422,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertStructurePropertyAt(options as any, index);
     }
 
-    
-
     /**
      * 添加数据结构属性
      * @param structurePropertyOptions 数据结构属性参数
@@ -476,9 +445,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -486,12 +452,10 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
-    
-
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -499,7 +463,7 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotationInReturnType(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
@@ -526,8 +490,6 @@ export class TypeAnnotation extends BaseNode {
         return params;
     }
 
-
-
     /**
      * 删除数据结构属性
      * @param structureProperty 已有的数据结构属性实例
@@ -535,7 +497,7 @@ export class TypeAnnotation extends BaseNode {
     removeStructureProperty(structureProperty: StructureProperty): void;
 
     removeStructureProperty(options: StructureProperty) {
-        let structureProperty: StructureProperty = options;
+        const structureProperty: StructureProperty = options;
         return structureProperty.delete();
     }
 
@@ -571,6 +533,24 @@ export class TypeAnnotation extends BaseNode {
         return this.headTitle;
     }
 
+    traverse(callback: (arg: TypeAnnotation) => void,
+        enter: (arg: TypeAnnotation) => void,
+        leave: (arg: TypeAnnotation) => void,
+        onJoin: (arg: TypeAnnotation, arg2: TypeAnnotation) => void) {
+        enter(this);
+        callback(this);
+        if (this.typeArguments && ['generic', 'union'].includes(this.typeKind)) {
+            const l = this.typeArguments.length;
+            this.typeArguments.forEach((arg, idx) => {
+                arg.traverse(callback, enter, leave, onJoin);
+                if (idx < l - 1) {
+                    onJoin(this, arg);
+                }
+            });
+        }
+        leave(this);
+    }
+
     get typeKey(): string {
         if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
             return `${this.typeNamespace}.${this.typeName}`;
@@ -578,7 +558,7 @@ export class TypeAnnotation extends BaseNode {
             return `${this.typeNamespace}.${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeKey)}>`;
         } else if (this.typeKind === 'anonymousStructure') {
             return `{ ${this.properties.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation.typeKey}`)).join(', ')} }`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.typeKey : '未知'}`)).join(', ')} }`;
         } else if (this.typeKind === 'union') {
             return `${this.typeArguments.map((arg) => arg.typeKey).join(' | ')}`;
         } else {
@@ -591,7 +571,7 @@ export class TypeAnnotation extends BaseNode {
         if (this.typeKind === 'anonymousStructure') {
             // 按匿名数据结构的key排序
             return `{${this.properties.sort(({ name: name1 }, { name: name2 }) => name1 > name2 ? 1 : -1).map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation.sortedTypeKey}`)).join(', ')}}`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.sortedTypeKey : '未知'}`)).join(', ')}}`;
         } else if (this.typeKind === 'union') {
             // 按返回的每个具体项排序
             return `${this.typeArguments.map((arg) => arg.sortedTypeKey).sort((name1, name2) => name1 > name2 ? 1 : -1).join(' | ')}`;
@@ -606,10 +586,12 @@ export class TypeAnnotation extends BaseNode {
         const typeKey = typeArr.join('.');
         if (this.typeKind === 'generic') {
             let code = typeKey;
+            code += '<';
             if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
                 // 必须按typeArguments定义的顺序，否则实参位置不对
-                code += `<${(this.typeArguments || []).map((arg) => arg.sortedTypeKey).join(', ')}>`;
+                code += `${(this.typeArguments || []).map((arg) => arg.sortedTypeKey).join(', ')}`;
             }
+            code += '>';
             return code;
         }
         return typeKey;
@@ -661,7 +643,7 @@ export class TypeAnnotation extends BaseNode {
             return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
         } else if (this.typeKind === 'anonymousStructure') {
             return `{ ${this.properties?.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation.typeTitle}`)).join(', ')} }`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`)).join(', ')} }`;
         } else if (this.typeKind === 'union') {
             return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
         } else {
@@ -676,9 +658,9 @@ export class TypeAnnotation extends BaseNode {
             const length = this.properties?.length;
             this.properties?.forEach(({ name, typeAnnotation }, index) => {
                 if (index === length - 1) {
-                    typeTitleList.push({ key: name, value: typeAnnotation.typeTitle });
+                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}` });
                 } else {
-                    typeTitleList.push({ key: name, value: typeAnnotation.typeTitle, dot: ',' });
+                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`, dot: ',' });
                 }
             });
             typeTitleList.push({ key: '}' });
@@ -797,9 +779,11 @@ export class TypeAnnotation extends BaseNode {
             let code = `{ __name: "AStructure_${this.hash}", `;
             (this.properties || []).forEach((property, i) => {
                 code += `${property.name}: `;
-                code += `${property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 }))}`;
-                code += i < this.properties?.length - 1 ? ', ' : ' }';
+                code += `${property.typeAnnotation ? property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 })) : '`未知`'}`;
+                if (i < this.properties?.length - 1)
+                    code += ', ';
             });
+            code += ' }';
             return code;
         } else {
             if (this.tsCalleeNamespace && this.typeName) {
@@ -824,7 +808,7 @@ export class TypeAnnotation extends BaseNode {
                     return 1;
                 return aName < bName ? -1 : 0;
             }).map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation.anonymousStructureTypeDesc}`)).join(', ')} }`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : '未知'}`)).join(', ')} }`;
         } else {
             return this.typeName;
         }
@@ -907,6 +891,43 @@ export class TypeAnnotation extends BaseNode {
         }
     }
 
+    // 是否是复合类型 List|Map|entities|structures
+    isComplexType() {
+        const namespaceType = this.typeNamespace.split('.').pop();
+        return ['Map', 'List'].includes(this.typeName) || (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType));
+    }
+    /*  类型签名 */
+    get sign() {
+        let str: string = '';
+        if (['Map', 'List'].includes(this.typeName)) {
+            str += this.typeName + '<';
+            (this.typeArguments || []).forEach((item, index) => {
+                str += item.sign;
+                if (index + 1 !== this.typeArguments.length) {
+                    str += ',';
+                }
+            });
+            str += '>';
+        } else {
+            str += this.typeName;
+        }
+        return str;
+    }
+
+    /* 判断2个类型是否一致 */
+    isSame(typeAnnotation: TypeAnnotation) {
+        typeAnnotation.typeArguments;
+        const typeAnnotation1 = this.toJSON();
+        const typeAnnotation2 = typeAnnotation.toJSON();
+        if (typeAnnotation1.typeArguments) {
+            typeAnnotation1.typeArguments = this.sortedTypeKey;
+        }
+        if (typeAnnotation2.typeArguments) {
+            typeAnnotation2.typeArguments = typeAnnotation.sortedTypeKey;
+        }
+        return JSON.stringify(typeAnnotation1) === JSON.stringify(typeAnnotation2);
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/ValidationRule__.ts

@@ -60,6 +60,8 @@ export class ValidationRule extends LogicItem {
     @property('LogicItem')
     errorMessage: LogicItem = undefined;
 
+    
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -73,6 +75,7 @@ export class ValidationRule extends LogicItem {
         return super.from(source, parentNode, parentKey) as ValidationRule;
     }
 
+    
     /**
      * 设置错误信息
      */
@@ -88,6 +91,10 @@ export class ValidationRule extends LogicItem {
         });
     }
 
+    
+
+    
+
     /**
     * 插入实际参数
     * @internal
@@ -120,6 +127,8 @@ export class ValidationRule extends LogicItem {
         return argument;
     }
 
+    
+
     /**
      * 插入实际参数
      * @param argumentOptions 实际参数参数
@@ -142,6 +151,8 @@ export class ValidationRule extends LogicItem {
         return node;
     }
 
+    
+
     /**
      * 添加实际参数
      * @internal
@@ -161,6 +172,8 @@ export class ValidationRule extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
+    
+
     /**
      * 添加实际参数
      * @param argumentOptions 实际参数参数
@@ -184,6 +197,9 @@ export class ValidationRule extends LogicItem {
         return node;
     }
 
+
+    
+
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -191,10 +207,12 @@ export class ValidationRule extends LogicItem {
     removeArgumentInArguments(argument: Argument): void;
 
     removeArgumentInArguments(options: Argument) {
-        const argument: Argument = options;
+        let argument: Argument = options;
         return argument.delete();
     }
 
+    
+
     /**
     * 删除逻辑项
     * @param name 逻辑项名称

package/src/concepts/Variable__.ts

@@ -240,7 +240,10 @@ export class Variable extends BaseNode {
     toJS(state?: TranslatorState): string {
         const context = this.view ? 'this' : 'Vue.prototype';
         const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
-        const needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
+        const needGenInitFromSchema = typeAnnotation && (
+            !['primitive', 'union'].includes(typeAnnotation.typeKind)
+            || typeAnnotation.typeName === 'DateTime'
+        );
         let code = `${this.name} =`;
         if (needGenInitFromSchema) {
             code += `${context}.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;