@lcap/nasl 2.20.0-beta.2 → 2.20.0

package/src/concepts/StringInterpolation__.ts

@@ -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,41 @@ 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(' + ');
+        if (!this.expressions.length)
+            return '';
+        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/StringLiteral__.ts

@@ -59,16 +59,16 @@ export class StringLiteral extends LogicItem {
     toVue(options?: ElementToVueOptions): string {
         let code = '';
         if (typeof this.value === 'string') {
-            code = `'${this.value}'`;
+            code = `\`${this.value}\``;
             if (options?.finalCode !== false) {
-                code = `'${this.value.replace(/['"`\\]/g, (m) => {
+                code = `\`${this.value.replace(/['"`\\]/g, (m) => {
                     const escape = '\\\\';
                     if (m === '\\') {
                         return `${escape}${escape}`;
                     } else {
                         return `${escape}${m}`;
                     }
-                })}'`;
+                })}\``;
             }
         }
         return code;
@@ -77,7 +77,7 @@ export class StringLiteral extends LogicItem {
     toUI(): string {
         let code = '';
         if (typeof this.value === 'string') {
-            code = `'${this.value}'`;
+            code = `\`${this.value}\``;
         }
         return code;
     }
@@ -85,12 +85,13 @@ export class StringLiteral extends LogicItem {
     toJS(): string {
         let code = ``;
         if (typeof this.value === 'string') {
-            code += `'${this.value.replace(/['"`\\]/g, (m) => `\\${m}`)}'`;
+            code += `\`${this.value.replace(/['"`\\]/g, (m) => `\\${m}`)}\``;
         }
         return code;
     }
+
     toBrief(): string {
-        return `'${this.value}'`
+        return `\`${this.value}\``;
     }
 
     @withSourceMap()

package/src/concepts/StructureProperty__.ts

@@ -226,11 +226,13 @@ export class StructureProperty extends BaseNode {
     //================================================================================
 
     get hasChildren() {
-        const { typeKind, typeNamespace } = this.typeAnnotation;
+        const { typeKind, typeName, typeNamespace } = this.typeAnnotation;
         if (typeKind === 'reference' || typeKind === 'generic') {
             if (typeNamespace.endsWith('.enums'))
                 return null;
             return [{}];
+        } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+            return [{}];
         }
         return null;
     }
@@ -274,6 +276,10 @@ export class StructureProperty extends BaseNode {
                     }
                 }
                 completionChildren = properties;
+            } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
+                completionChildren = properties;
             } else {
                 completionChildren = [];
             }

package/src/concepts/TypeAnnotation__.ts

@@ -121,6 +121,8 @@ export class TypeAnnotation extends BaseNode {
     @property()
     ruleMap: Object = undefined;
 
+    
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -157,6 +159,10 @@ export class TypeAnnotation extends BaseNode {
         });
     }
 
+    
+
+    
+
     /**
     * 插入类型标注
     * @internal
@@ -189,6 +195,8 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
+    
+
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -211,6 +219,8 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加类型标注
      * @internal
@@ -230,6 +240,8 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
     }
 
+    
+
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -253,6 +265,8 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+    
+
     /**
     * 插入类型标注
     * @internal
@@ -285,6 +299,8 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
+    
+
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -307,6 +323,8 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加类型标注
      * @internal
@@ -326,6 +344,8 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationInReturnTypeAt(options as any, index);
     }
 
+    
+
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -349,6 +369,11 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+
+
+
+    
+
     /**
     * 插入数据结构属性
     * @internal
@@ -381,6 +406,8 @@ export class TypeAnnotation extends BaseNode {
         return structureProperty;
     }
 
+    
+
     /**
      * 插入数据结构属性
      * @param structurePropertyOptions 数据结构属性参数
@@ -403,6 +430,8 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加数据结构属性
      * @internal
@@ -422,6 +451,8 @@ export class TypeAnnotation extends BaseNode {
         return this._insertStructurePropertyAt(options as any, index);
     }
 
+    
+
     /**
      * 添加数据结构属性
      * @param structurePropertyOptions 数据结构属性参数
@@ -445,6 +476,9 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -452,10 +486,12 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
-        const typeAnnotation: TypeAnnotation = options;
+        let typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
+    
+
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -463,7 +499,7 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotationInReturnType(options: TypeAnnotation) {
-        const typeAnnotation: TypeAnnotation = options;
+        let typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
@@ -490,6 +526,8 @@ export class TypeAnnotation extends BaseNode {
         return params;
     }
 
+
+
     /**
      * 删除数据结构属性
      * @param structureProperty 已有的数据结构属性实例
@@ -497,7 +535,7 @@ export class TypeAnnotation extends BaseNode {
     removeStructureProperty(structureProperty: StructureProperty): void;
 
     removeStructureProperty(options: StructureProperty) {
-        const structureProperty: StructureProperty = options;
+        let structureProperty: StructureProperty = options;
         return structureProperty.delete();
     }
 
@@ -558,7 +596,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 ? typeAnnotation.typeKey : 'any'}`)).join(', ')} }`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.typeKey : '未知'}`)).join(', ')} }`;
         } else if (this.typeKind === 'union') {
             return `${this.typeArguments.map((arg) => arg.typeKey).join(' | ')}`;
         } else {
@@ -571,7 +609,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 ? typeAnnotation.sortedTypeKey : 'any'}`)).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(' | ')}`;
@@ -643,7 +681,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 ? typeAnnotation.typeTitle : 'any'}`)).join(', ')} }`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`)).join(', ')} }`;
         } else if (this.typeKind === 'union') {
             return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
         } else {
@@ -651,19 +689,52 @@ export class TypeAnnotation extends BaseNode {
         }
     }
 
+    /**
+     * 用于展示的 纯中文的type 标题
+     */
+    get typeChineseTitle(): string {
+        if (this.typeKind === 'primitive') {
+            return `${PRIMITIVE_TITLE[this.typeName] || ''}`;
+        } else if (this.typeKind === 'reference') {
+            return this.typeName;
+        } else if (this.typeKind === 'generic') {
+            return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeChineseTitle || arg.name || 'T').join(', ')}>`;
+        } else if (this.typeKind === 'anonymousStructure') {
+            return `{ ${this.properties?.map(({ name, typeAnnotation }) =>
+                (`${name}: ${typeAnnotation ? typeAnnotation.typeChineseTitle : '未知'}`)).join(', ')} }`;
+        } else if (this.typeKind === 'union') {
+            return `${this.typeArguments.map((arg) => arg.typeChineseTitle || arg.name).join(' 或 ')}`;
+        } else {
+            return this.typeName;
+        }
+    }
+
     get typeTitleList() {
-        const typeTitleList = [];
+        const typeTitleList: any[] = [];
         if (this.typeKind === 'anonymousStructure') {
             typeTitleList.push({ key: '{' });
             const length = this.properties?.length;
             this.properties?.forEach(({ name, typeAnnotation }, index) => {
                 if (index === length - 1) {
-                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : 'any'}` });
+                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}` });
                 } else {
-                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : 'any'}`, dot: ',' });
+                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`, dot: ',' });
                 }
             });
             typeTitleList.push({ key: '}' });
+        } else if (this.typeName === 'List') {
+            const propsTypeList = [].concat(...this.typeArguments.map((arg) => arg.typeTitleList));
+            if (propsTypeList[0]?.key === '{') {
+                propsTypeList[0].key = 'List<{';
+            } else {
+                typeTitleList.push({ key: 'List<' });
+            }
+            typeTitleList.push(...propsTypeList);
+            if (propsTypeList[propsTypeList.length - 1]?.key === '}') {
+                propsTypeList[propsTypeList.length - 1].key = '}>';
+            } else {
+                typeTitleList.push({ key: '>' });
+            }
         } else {
             typeTitleList.push({ key: this.typeTitle });
         }
@@ -779,9 +850,11 @@ export class TypeAnnotation extends BaseNode {
             let code = `{ __name: "AStructure_${this.hash}", `;
             (this.properties || []).forEach((property, i) => {
                 code += `${property.name}: `;
-                code += `${property.typeAnnotation ? property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 })) : 'any'}`;
-                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) {
@@ -806,7 +879,7 @@ export class TypeAnnotation extends BaseNode {
                     return 1;
                 return aName < bName ? -1 : 0;
             }).map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : 'any'}`)).join(', ')} }`;
+                (`${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : '未知'}`)).join(', ')} }`;
         } else {
             return this.typeName;
         }
@@ -823,7 +896,7 @@ export class TypeAnnotation extends BaseNode {
         let code = '';
         if (this.typeKind === 'primitive') {
             if (this.typeName === 'String') {
-                code = `   "${value}" `;
+                code = `   new nasl.core.String("${value}") `;
             } else {
                 if (['Text'].includes(this.typeName)) {
                     code = `  new ${this.typeNamespace}.${this.typeName}("${value}")`;
@@ -891,7 +964,7 @@ export class TypeAnnotation extends BaseNode {
 
     // 是否是复合类型 List|Map|entities|structures
     isComplexType() {
-        const namespaceType = this.typeNamespace.split('.').pop();
+        const namespaceType = this.typeNamespace?.split('.').pop();
         return ['Map', 'List'].includes(this.typeName) || (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType));
     }
     /*  类型签名 */
@@ -912,6 +985,20 @@ export class TypeAnnotation extends BaseNode {
         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,7 +60,7 @@ export class ValidationRule extends LogicItem {
     @property('LogicItem')
     errorMessage: LogicItem = undefined;
 
-    
+
 
     /**
      * @param source 需要合并的部分参数
@@ -75,7 +75,7 @@ export class ValidationRule extends LogicItem {
         return super.from(source, parentNode, parentKey) as ValidationRule;
     }
 
-    
+
     /**
      * 设置错误信息
      */
@@ -91,9 +91,9 @@ export class ValidationRule extends LogicItem {
         });
     }
 
-    
 
-    
+
+
 
     /**
     * 插入实际参数
@@ -127,7 +127,7 @@ export class ValidationRule extends LogicItem {
         return argument;
     }
 
-    
+
 
     /**
      * 插入实际参数
@@ -151,7 +151,7 @@ export class ValidationRule extends LogicItem {
         return node;
     }
 
-    
+
 
     /**
      * 添加实际参数
@@ -172,7 +172,7 @@ export class ValidationRule extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
-    
+
 
     /**
      * 添加实际参数
@@ -198,7 +198,7 @@ export class ValidationRule extends LogicItem {
     }
 
 
-    
+
 
     /**
      * 删除实际参数
@@ -211,7 +211,7 @@ export class ValidationRule extends LogicItem {
         return argument.delete();
     }
 
-    
+
 
     /**
     * 删除逻辑项
@@ -265,6 +265,55 @@ export class ValidationRule extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    toInViewMethod() {
+        let code = '{';
+        // 兼容就得简写模式
+        if (this.calleeName && this.calleeName.includes('(')) {
+            return `'${this.calleeName}'`;
+        } else if (this.calleeName === 'unique') {
+            code += `validate: 'excluded',`;
+        } else if (this.calleeName === 'confirmed') {
+            code += `validate: 'is',`;
+        } else {
+            code += `validate: '${this.calleeName}',`;
+        }
+        if (this.arguments.length) {
+            let args = '[';
+            this.arguments?.forEach((arg, index) => {
+                args += arg?.toJS();
+                if (index !== this.arguments?.length - 1)
+                    args += ', ';
+            });
+            args += ']';
+            code += `args: ${args} ,`;
+        }
+        if (this.errorMessage) {
+            code += `message: ${this.errorMessage?.toJS()},`;
+        } else {
+            let defaultError = (defaultErrorMessage as Record<string, string>)[this.calleeName];
+            let index = 0;
+            while (defaultError && defaultError.indexOf(`{args}`) !== -1) {
+                defaultError = defaultError.replace(`{args}`, `\${${this.arguments[index]?.toJS()}}`);
+                index++;
+            }
+            const itemTitle = (this?.parentNode as any)?.parentNode?.bindAttrs?.find((item: BindAttribute) => item.name === 'label');
+            let labelName;
+            if (itemTitle?.expression?.toJS()) {
+                labelName = `\${${itemTitle?.expression?.toJS()}}`;
+            } else {
+                labelName = itemTitle?.value || '表单项';
+            }
+            defaultError = defaultError && defaultError.replace(`{label}`, labelName);
+            code += `message: \`${defaultError}\`,`;
+        }
+        code += `trigger: 'input+blur'`;
+        if (['required', 'filled', 'notEmpty'].includes(this.calleeName)) {
+            code += ',required: true';
+        }
+        code += '}';
+        return code;
+    }
+
     toVue(options?: ElementToVueOptions) {
         let code = '{';
         // 兼容就得简写模式

package/src/concepts/Variable__.ts

@@ -175,6 +175,10 @@ export class Variable extends BaseNode {
         });
     }
 
+    
+
+    
+
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -413,9 +417,11 @@ export class Variable extends BaseNode {
             return null;
         const { typeKind, typeName, typeNamespace } = this.typeAnnotation;
         if (typeKind === 'reference' || typeKind === 'generic') {
-            if (typeNamespace.endsWith('.enums') || (typeNamespace.endsWith('.collection') && typeName === 'Map'))
+            if (typeNamespace.endsWith('.enums'))
                 return null;
             return [{}];
+        } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+            return [{}];
         }
         return null;
     }
@@ -451,6 +457,10 @@ export class Variable extends BaseNode {
                     }
                 }
                 completionChildren = properties;
+            } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
+                completionChildren = properties;
             } else {
                 completionChildren = [];
             }