@lcap/nasl 2.19.0-beta.1 → 2.19.0-beta.3

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();
     }
 

package/src/concepts/ViewElement__.ts

@@ -1501,7 +1501,7 @@ export class ViewElement extends BaseNode {
             this.children.forEach((element) => {
                 code += element.toEmbeddedTS(shiftState(state, code, {
                     tabSize: (state?.tabSize || 0),
-                }));
+                }), levelIndex);
             });
             code += indent((state?.tabSize || 0) + 2);
             code += ']';

package/src/concepts/View__.ts

@@ -259,7 +259,7 @@ export class View extends BaseNode {
         });
     }
 
-    
+
 
     /**
     * 插入页面元素
@@ -1095,7 +1095,7 @@ export class View extends BaseNode {
     }
 
 
-    
+
 
     /**
     * 删除页面元素
@@ -2101,6 +2101,7 @@ export class View extends BaseNode {
     }
 
     getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string {
+        code = code.replaceAll('\n', ' ');
         const logic = assignment.logic;
         const logicRtn = logic?.returns[0];
         // 调用接口，参数替换成 null

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -1078,7 +1078,8 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'formatter',
-                    defaultValue: '格式化规则，默认为yyyy-MM-dd，即年月日格式',
+                    description: '格式化规则，默认为yyyy-MM-dd，即年月日格式',
+                    defaultValue: 'yyyy-MM-dd',
                     defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd' }),
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
@@ -1100,8 +1101,9 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'formatter',
+                    description: '格式化规则，默认为yyyy-MM-dd',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultValue: '格式化规则，默认为yyyy-MM-dd',
+                    defaultValue: 'yyyy-MM-dd HH:mm:ss',
                     defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
                 }),
             ],

package/src/generator/genBundleFiles.ts

@@ -370,9 +370,18 @@ export function genBundleFiles(app: App,
             sourceMap: {
                 url: bundleSourceMapPath,
             },
+            compress: {
+                // @ts-ignore
+                awaits: false,
+            },
         });
     } else {
-        minifyObj = UglifyJS.minify(content);
+        minifyObj = UglifyJS.minify(content, {
+            compress: {
+                // @ts-ignore
+                awaits: false,
+            },
+        });
     }
     const outputs = [
         {

package/src/generator/genReleaseBody.ts

@@ -1,4 +1,4 @@
-import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, MemberExpression, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, StringInterpolation } from '../concepts';
+import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, MemberExpression, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, StringInterpolation, ExternalDestination } from '../concepts';
 import { genBundleFiles } from './genBundleFiles';
 import { genPermissionData } from './permission';
 
@@ -265,6 +265,8 @@ function getAuthApiPathList(app: App) {
             logicItems = [state.object, state.property];
         } else if (state instanceof StringInterpolation) {
             logicItems = [...state.expressions];
+        } else if (state instanceof ExternalDestination) {
+            logicItems = [state.anchor, state.link];
         }
 
         return logicItems.filter((item) => !!item);

package/src/server/extendBaseNode.ts

@@ -87,7 +87,10 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
          */
         const res = naslServer._renamePrepare(this, refsList, newValue);
         if (res.length <= 1) {
-            (this as SetNameNode).setName(newValue);
+            if (this.concept === 'enumItem') {
+                (this as any).setValue(newValue);
+            } else
+                (this as SetNameNode).setName(newValue);
         } else {
             const callback = (value: boolean) => {
                 if (value) {

package/src/server/formatTsUtils.ts

@@ -45,16 +45,19 @@ export function type2TypeAnnotation(oldType: Array<any> | {}): TypeAnnotation {
     let typeAnnotation: TypeAnnotation;
     try {
         const { typeName, typeNamespace, typeArguments, typeKind, properties } = type as any;
-        if (typeKind === 'anonymousStructure' && Array.isArray(properties) && properties.length) {
+        if (typeKind === 'anonymousStructure') {
             // 自定义类型
             const newProperties: StructureProperty[] = [];
-            properties.forEach((item) => {
-                if (!item?.name?.startsWith('__')) {
-                    const itemType = type2TypeAnnotation(item.typeInfo);
-                    const structureProperty = StructureProperty.from({ name: item.name, typeAnnotation: itemType }, typeAnnotation, 'properties');
-                    newProperties.push(structureProperty);
-                }
-            });
+            if (Array.isArray(properties) && properties.length) {
+                properties.forEach((item) => {
+                    if (!item?.name?.startsWith('__')) {
+                        // 如果没有获取到类型，就默认塞一个string
+                        const itemType = type2TypeAnnotation(item.typeInfo) || TypeAnnotation.createPrimitive('String');
+                        const structureProperty = StructureProperty.from({ name: item.name, typeAnnotation: itemType }, typeAnnotation, 'properties');
+                        newProperties.push(structureProperty);
+                    }
+                });
+            }
             typeAnnotation = TypeAnnotation.createTypeAnonymousStructure(newProperties);
         } else if (!typeName || typeName === 'Promise' || typeName === 'nasl' || typeName === '___IDENTIFIER__') {
             return null;

package/src/server/naslServer.ts

@@ -61,6 +61,8 @@ import {
     BooleanLiteral,
     BatchAssignment,
     ForEachStatement,
+    NewList,
+    NewMap,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem } from '../translator';
 import axios from '../service/storage';
@@ -844,8 +846,8 @@ export class NaslServer {
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
             record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`
-                    , `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
+                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`,
+                    `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
 
@@ -1000,6 +1002,114 @@ export class NaslServer {
                             }
                         }
                     }
+                } else if (node instanceof NewList && !node.typeAnnotation) {
+                    const { items } = node || {};
+                    const typeAnnotationMap: any = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo: any = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(items)) {
+                        items.forEach((item) => {
+                            const typeAnnotation = item.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        items: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.items.push(item);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const {
+                        typeAnnotation: maxTypeAnnotation,
+                    } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, items } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(items)) {
+                                items.forEach((item) => {
+                                    const diagnostic = {
+                                        node: item,
+                                        severity: 'warning',
+                                        message: `NewList期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    item.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                } else if (node instanceof NewMap && !node.typeAnnotation) {
+                    const { values } = node || {};
+                    const typeAnnotationMap: any = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo: any = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(values)) {
+                        values.forEach((value) => {
+                            if (!value)
+                                return;
+                            const typeAnnotation = value.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        values: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.values.push(value);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const {
+                        typeAnnotation: maxTypeAnnotation,
+                    } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, values } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(values)) {
+                                values.forEach((value) => {
+                                    const diagnostic = {
+                                        node: value,
+                                        severity: 'warning',
+                                        message: `NewMap中values值所期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    value.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
                 }
             });
         }
@@ -1297,15 +1407,18 @@ export class NaslServer {
                 }
             });
         }
-        if (node instanceof MatchCase && (node.getAncestor('Match') as Match)?.isExpression && node.body.length === 0 && !node.isDisabled) {
-            const diagnostic = {
-                node,
-                severity: 'error',
-                message: '匹配分支：表达式不能为空',
-                titleTip: '表达式不能为空',
-            };
-            node.tsErrorDetail = diagnostic;
-            diagnostics.push(diagnostic);
+        if (node instanceof MatchCase && (node.getAncestor('Match') as Match)?.isExpression && node.body.length === 0) {
+            // 如果不是其他就标红
+            if ((node?.getIndexOfParent() !== ((node.getAncestor('Match') as Match)?.cases?.length || 0) - 1)) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配分支：表达式不能为空',
+                    titleTip: '表达式不能为空',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
         }
         // 如果节点是match的patterns 里的
         if (node?.parentKey === 'patterns' && node.parentNode instanceof MatchCase) {

package/src/server/translator.ts

@@ -49,6 +49,7 @@ import {
     OqlQueryComponent,
     NewMap,
     NewList,
+    NewComposite,
 } from '../concepts';
 import { SourceMapItem } from '../translator';
 import { Diagnostic } from '../manager/diagnostic';
@@ -377,7 +378,7 @@ const TS_RULES: Array<{
     },
     {
         re: /Variable '(.+?)' implicitly has an 'any' type./,
-        result: '$1推断不出类型！请连线或手动设置',
+        result: '$1推导不出类型！请连线或手动设置',
         transforms: [transformType],
     },
 ];
@@ -532,8 +533,14 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
                 // node = node.getAncestor('CallLogic');
                 tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '赋值：类型不一致！右边类型：').replace('接收类型：', '左边类型：');
             }
-        } else if (node.parentNode instanceof NewMap && text.includes(`is not assignable to parameter of type 'None'`)) {
-            tsErrorDetail.message = tsErrorDetail.message = `'参数类型不一致！', 'map的key类型只能是String | Integer | Boolean | Long | Decimal'的其中一种`;
+        } else if (node.parentNode instanceof NewMap) {
+            if (text.includes(`is not assignable to parameter of type 'None'`)) {
+                tsErrorDetail.message = tsErrorDetail.message = `'参数类型不一致！', 'map的key类型只能是String | Integer | Boolean | Long | Decimal'的其中一种`;
+            } else if (text.includes(`parameter of type 'never'`)) {
+                tsErrorDetail.message = '自动推导不出类型！newMap中有未知类型';
+            }
+        } else if (node.parentNode instanceof NewList && text.includes(`parameter of type 'never'`)) {
+            tsErrorDetail.message = '自动推导不出类型！newList中有未知类型';
         }
     }
     if (node instanceof Argument || node instanceof Anchor) {
@@ -567,7 +574,6 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
     if (node instanceof OqlQueryComponent) {
         console.log(minRange, tsErrorDetail);
     }
-    console.log(node, text)
     // 类型报错的，需要放到上一级
     if (/'(.+?)' has no exported member(?: named)? '(.+?)'/.exec(text) || /Property '(.+?)' does not exist on type '(.+?)'./.exec(text)) {
         if (node instanceof TypeAnnotation) {
@@ -605,9 +611,9 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
         } else if (node instanceof ProcessOutcome || node instanceof Function || node instanceof MatchCase) {
             tsErrorDetail.message = (node as any).constructor.nodeTitle + '：不能为空！';
         } else if (node instanceof NewMap) {
-            tsErrorDetail.message = 'Map推断不出类型！请手动设置！';
+            tsErrorDetail.message = 'Map推导不出类型！请手动设置！';
         } else if (node instanceof NewList) {
-            tsErrorDetail.message = 'List推断不出类型！请手动设置！';
+            tsErrorDetail.message = 'List推导不出类型！请手动设置！';
         } else if (node instanceof Argument) {
             let str = tsErrorDetail.message;
             str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
@@ -659,7 +665,7 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
                 .replace('左边类型', '接收类型')
                 .replace('右边类型', '传入类型');
         } else if (text === `Type 'void' is not assignable to type 'never'.`) {
-            tsErrorDetail.message = `${node.name}推断不出类型！请连线或手动设置`;
+            tsErrorDetail.message = `${node.name}推导不出类型！请连线或手动设置`;
         }
     }
     // 参数类型不一致！
@@ -690,12 +696,33 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
         }
     }
     if (/Variable '(.+?)' implicitly has an 'any' type./.exec(text) || /Variable '(.+?)' implicitly has an 'any\[\]' type./.exec(text)) {
-        if (node instanceof NewMap || node instanceof NewList || node instanceof Logic)
+        if (node.parentNode instanceof NewComposite) {
+            //
+        } else if (node.parentNode instanceof NewList) {
+            tsErrorDetail.message = tsErrorDetail.message.replace('！请连线或手动设置', '');
+        } else if (node.parentNode instanceof NewMap) {
+            tsErrorDetail.message = tsErrorDetail.message.replace('！请连线或手动设置', '');
+        } else {
             return;
+        }
     }
     for (const rule of POST_RULES) {
-        if (rule.re.test(tsErrorDetail.message))
-            tsErrorDetail.message = tsErrorDetail.message.replace(rule.re, rule.result);
+        if (rule.re.test(tsErrorDetail.message)) {
+            tsErrorDetail.message = tsErrorDetail.message.replace(rule.re, (value, index, oldStr) => {
+                // 处理匹配到的值的左右的内容，是不是还是字母，要是字母就原样输出，防止展示问题
+                try {
+                    const leftCode = index - 1 < 0 ? '' : oldStr[index - 1];
+                    const rightCode = oldStr[index + value.length] || '';
+                    if (/^[A-Za-z]+$/.test(leftCode) || /^[A-Za-z]+$/.test(rightCode)) {
+                        return value;
+                    } else {
+                        return rule.result;
+                    }
+                } catch (err) {
+                    return value;
+                }
+            });
+        }
     }
     node.tsErrorDetail = tsErrorDetail;
     // 如果logic中有报错就把标识置为true

package/src/service/creator/add.configs.js

@@ -22,6 +22,9 @@ function httpCode(response, params, requestInfo) {
 }
 
 function shortResponse(response, params, requestInfo) {
+    if(params === false)
+        return response;
+
     if (response.data && response.data.result !== undefined) {
         return response.data.result;
     } else {

package/src/service/creator/errHandles.js

@@ -32,6 +32,12 @@ export default {
             return;
         }
 
+        // 检测到当前应用已在新 tab 页打开
+        if(err.code === 500502) {
+            eventBus.emit('multiTabOpened');
+            return;
+        }
+
         if (versionStatus[err.code])
             eventBus.emit('updateVersionStatus', {
                 status: versionStatus[err.code],

package/src/service/creator/index.js

@@ -48,6 +48,9 @@ const requester = function (requestInfo) {
         withCredentials: !baseURL,
     };
 
+    if(config.timeout)
+        requestOptions.timeout = config.timeout;
+        
     if (aslConfig.debugRequestAll || (aslConfig.debugRequest && requestOptions.method !== 'GET')) {
         console.debug('[Request Debug]', requestOptions);
     }

package/src/service/storage/api.js

@@ -11,4 +11,16 @@ export default {
             path: '/proxy/nasl-storage/api/storage/batchAction',
         },
     },
+    batchInstruct: {
+        url: {
+            method: 'post',
+            path: '/proxy/nasl-storage/api/storage/batchInstruct',
+        },
+    },
+    saveFrontendNasl: {
+        url: {
+            method: 'post',
+            path: '/proxy/nasl-storage/api/storage/saveFrontendNasl',
+        },        
+    },
 };