@lcap/nasl 2.20.0-beta.4 → 2.20.0-beta.5

package/src/concepts/View__.ts

@@ -1765,16 +1765,22 @@ export class View extends BaseNode {
                 // 子页面内部逻辑过滤
                 if (el.view !== this)
                     return;
-                let jsCode = '';
-                try {
-                    jsCode = el.toJS();
-                } catch (error) {
-
-                }
-                const advanceVar = this.variables?.find((variable) =>
-                    !variable.typeAnnotation && jsCode.startsWith(`this.${variable.name} = `));
-                if (advanceVar && !advanceMap.get(advanceVar)) {
-                    advanceMap.set(advanceVar, el);
+                if (el instanceof Assignment) {
+                    const advanceVar = this.variables?.find((variable) =>
+                        !variable.typeAnnotation && el.left?.name === variable.name);
+                    if (advanceVar && !advanceMap.get(advanceVar)) {
+                        advanceMap.set(advanceVar, el);
+                    }
+                } else if (el instanceof BatchAssignment) {
+                    el.assignmentLines.forEach(({ leftIndex }) => {
+                        const leftCode
+                            = leftIndex.length === 1 ? el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) : el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                        const advanceVar = this.variables?.find((variable) =>
+                            !variable.typeAnnotation && leftCode === variable.name);
+                        if (advanceVar && !advanceMap.get(advanceVar)) {
+                            advanceMap.set(advanceVar, el);
+                        }
+                    });
                 }
             }
         });
@@ -1992,12 +1998,15 @@ export class View extends BaseNode {
         this.elements.forEach((item) => {
             utils.traverse((current) => {
                 const { node } = current as any;
-                // 处理三种情况
-                if (
-                    ['BindAttribute', 'BindDirective', 'BindStyle'].includes(node.concept)
-                    && node.needReplaceWithIdentifier
-                ) {
-                    bindExpressions.push(node);
+                //// 处理三种情况
+                //if (
+                //    ['BindAttribute', 'BindDirective', 'BindStyle'].includes(node.concept)
+                //    && node.needReplaceWithIdentifier
+                //) {
+                //    bindExpressions.push(node);
+                //}
+                if (node.concept === 'Match') {
+                    bindExpressions.push(node as Match);
                 }
             }, {
                 node: item,
@@ -2208,8 +2217,8 @@ export class View extends BaseNode {
         return code;
     }
 
-    getViewCallLogics():string[] {
-        const callbackLogics :string[] = [];
+    getViewCallLogics(): string[] {
+        const callbackLogics: string[] = [];
         this.traverseChildren((el) => {
             if (el instanceof Identifier && el.namespace?.endsWith('logics')) {
                 callbackLogics.push(el.namespace + '.' + el.name);

package/src/generator/genReleaseBody.ts

@@ -1,6 +1,6 @@
 import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, MemberExpression, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, StringInterpolation, Frontend, ExternalDestination, NewComposite, SelectMembers, NewList } from '../concepts';
 import { genFrontendBundleFiles } from './genBundleFiles';
-import { genPermissionData } from './permission';
+import { genPermissionData, genLogicAuthFlag } from './permission';
 import * as utils from '../utils';
 
 export async function genReleaseBody(app: App, {
@@ -47,6 +47,7 @@ export async function genReleaseBody(app: App, {
     const body = {
         ...authReport, // 如果发布需要上报权限，导出源码不需要
         logicPageResourceDtoList,
+        logicAuthFlag: genLogicAuthFlag(app),
         noAuthApiPathList: getAuthApiPathList(app, frontends),
         reportIdList: findAllReportIdList(app, frontends),
         appId: app.id,

package/src/generator/permission.ts

@@ -102,13 +102,11 @@ function findResourcesOfUI(view: View | ViewElement) {
                 path: node.authPath,
                 type: 'page',
             });
-        else if (node instanceof ViewElement) {
-            const hasAuth = node.bindDirectives.find((directive) => directive.name === 'auth');
-            if (hasAuth)
-                res.push({
-                    path: node.authPath,
-                    type: 'component',
-                });
+        else if (node instanceof ViewElement && node.auth) {
+            res.push({
+                path: node.authPath,
+                type: 'component',
+            });
         }
         node = node.parentNode;
     }
@@ -275,3 +273,15 @@ export async function genPermissionData(app: App) {
     // console.timeEnd('xxx');
     return logicPageResourceDtoList;
 }
+
+export function genLogicAuthFlag(app: App) {
+    let flag = false;
+    app.traverseChildren((node) => {
+        if(flag) return;
+
+        if((node instanceof View || node instanceof ViewElement) && node.auth)
+            flag = true;
+    });
+
+    return flag;
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 export { EventEmitter, EventPayload, BaseNode } from './common';
 export * from './concepts';
-export { genBundleFiles, genFrontendBundleFiles, genMetaData, genReleaseBody, genPermissionData } from './generator';
+export { genBundleFiles, genFrontendBundleFiles, genMetaData, genReleaseBody, genPermissionData, genLogicAuthFlag } from './generator';
 export * from './translator';
 // export { default as diagnosticManager } from './manager/diagnostic';
 export { default as server, NaslServer } from './server';

package/src/server/naslServer.ts

@@ -1104,7 +1104,7 @@ export class NaslServer {
                                     if (Array.isArray(body) && body.length) {
                                         const lastExpression = body[body.length - 1];
                                         diagnostic.node = lastExpression;
-                                        diagnostic.message = `${lastExpression?.toUI()}期望的类型是${maxTypeAnnotation?.headTitle}`;
+                                        diagnostic.message = `匹配：该分支类型与多数类型不一致，将产生Union类型。当前类型：${typeAnnotation?.headTitle}，多数类型：${maxTypeAnnotation?.headTitle}`;
                                         this.baseNodeAssignmentTsError(lastExpression, diagnostic);
                                         diagnostics.push(diagnostic);
                                     }
@@ -1378,7 +1378,12 @@ export class NaslServer {
                                 if (node.logic && node.logic !== nodeIn.logic)
                                     return;
                                 // 跟变量无关的赋值过滤
-                                const jsCode = nodeIn.toJS();
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                } catch (err) {
+                                    console.log(err);
+                                }
                                 if (!jsCode.includes(`${node.name} = `))
                                     return;
                                 // 页面局部变量
@@ -1551,16 +1556,24 @@ export class NaslServer {
                         fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
                             if (!used && nodeIn
                                 && (nodeIn instanceof BatchAssignment || (nodeIn instanceof Assignment && nodeIn.left?.name))
-                                && nodeIn.toJS().includes(`${node.name} = `)) {
-                                used = true;
-                                if (!nodeIn.tsErrorDetail) {
-                                    const diagnostic = {
-                                        node: nodeIn,
-                                        severity: 'error',
-                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
-                                    };
-                                    nodeIn.tsErrorDetail = diagnostic;
-                                    diagnostics.push(diagnostic);
+                            ) {
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                } catch (err) {
+                                    console.log(err);
+                                }
+                                if (jsCode.includes(`${node.name} = `)) {
+                                    used = true;
+                                    if (!nodeIn.tsErrorDetail) {
+                                        const diagnostic = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic;
+                                        diagnostics.push(diagnostic);
+                                    }
                                 }
                             }
                         });
@@ -1649,8 +1662,8 @@ export class NaslServer {
                 const diagnostic = {
                     node,
                     severity: 'error',
-                    message: '匹配分支：表达式不能为空',
-                    titleTip: '表达式不能为空',
+                    message: '匹配分支：返回内容不能为空',
+                    titleTip: '返回内容不能为空',
                 };
                 node.tsErrorDetail = diagnostic;
                 diagnostics.push(diagnostic);
@@ -1766,6 +1779,8 @@ export class NaslServer {
                     // 先特殊处理等 类型合并后就可以去掉了
                     if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
                         return null;
+                    } else if (['nasl.collection.List<>'].includes(leftType.sortedTypeKey) || ['nasl.collection.List<>'].includes(rightType.sortedTypeKey)) {
+                        return null;
                     }
                     const diagnostic = {
                         node: node.right,
@@ -2775,6 +2790,7 @@ export class NaslServer {
             && !(fileNode.parentNode instanceof App)
             && !(fileNode.parentNode instanceof Module)
             && !(fileNode.parentNode instanceof DataSource)
+            && !(fileNode.parentNode instanceof Frontend)
             && !(fileNode instanceof View)
             && !(fileNode instanceof ConfigProperty)
         ) {
@@ -3024,7 +3040,11 @@ export class NaslServer {
                 }
             } else if (node.concept === 'Match') {
                 // 去查return 后面的返回值，变成函数调用
-                fileDetail.line = item.range.end.line - 1;
+                if (item.code?.endsWith(';\n')) {
+                    fileDetail.line = item.range.end.line - 1;
+                } else {
+                    fileDetail.line = item.range.end.line;
+                }
                 const indexOf = item.code.indexOf('return __MatchExpressionFuntion');
                 let newCode = item.code.substring(0, indexOf);
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
@@ -3076,8 +3096,8 @@ export class NaslServer {
                 // 直接从最后一项的返回值取，有就有没有就没有
                 if (node.body?.length) {
                     const last = node.body[node.body.length - 1];
-                    if (last.__TypeAnnotation) {
-                        types.set(node, last.__TypeAnnotation);
+                    if (types.get(last)) {
+                        types.set(node, types.get(last));
                     }
                 }
             }

package/src/server/translator.ts

@@ -537,7 +537,7 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
     // 赋值左右侧类型不一致, 把文字换一下
     if (/Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text)) {
         if (node instanceof OqlQueryComponent) {
-            tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '类型不一致！传入类型：').replace('接收类型：', '期待类型：');
+            tsErrorDetail.message = tsErrorDetail.message.replace('参数类型不一致！传入类型：', '类型不一致！传入类型：').replace('接收类型：', '期望类型：');
         } else if (node.parentNode instanceof Assignment) {
             // OQL 的返回类型报错需要转换翻译，其内部 SQL 语句的参数类型报错不转换翻译
             if (node instanceof OqlQueryComponent) {

package/src/service/storage/init.ts

@@ -318,7 +318,7 @@ async function doAction(app: any, actionItem: any) {
             undo: '已撤销操作：',
             redo: '已重做操作：',
         };
-        let msg = actionMap[action as 'undo' | 'redo'];
+        let msg = actionMap[action as 'undo' | 'redo'] || '';
         msg += actionMsg;
         Vue.prototype.$toast.info(msg);
         app._historying = false;

package/src/translator/index.ts

@@ -89,7 +89,9 @@ export function withSourceMap() {
         descriptor.value = function (this: BaseNode, state?: TranslatorState, ...args: any[]) {
             // 重新生成ts代码就先把类型清除掉
             // 注意排查错误的时候，调用了这个方法，就会把节点上缓存的__TypeAnnotation清除
-            this.__isCorrectTypeAnnotation = false;
+            try {
+                this.__isCorrectTypeAnnotation = false;
+            } catch (err) {}
             if (!state) {
                 // 没有状态不生成 SourceMap
                 return oldMethod.call(this);