@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/out/server/naslServer.js

@@ -264,8 +264,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
     terminate() {
         this.worker.terminate();
     }
-    async createUiTs(components, options) {
-        const { tsCode, baseComponents } = options;
+    async createUiTs(components, optinos) {
+        const { standardUIComponents, // 标准组件（带有ts类型定义文件的组件）
+         } = optinos;
         Object.assign(allComponent, components);
         const { code, elementsLogic } = await (0, createUiTs_1.default)(allComponent);
         ///  process.env.BUILD_TARGET !== 'node'
@@ -289,12 +290,18 @@ let NaslServer = NaslServer_1 = class NaslServer {
             fileContent: code,
         }, { cache: true });
         // 添加基础组件的方法到elementsLogic
-        Object.assign(elementsLogic, (0, createUiTs_1.createEleLogins)(baseComponents));
+        Object.assign(elementsLogic, (0, createUiTs_1.createEleLogins)(standardUIComponents));
         // 基础组件
         await this.addFile({
             file: 'nasl.ui.component.ts',
-            fileContent: tsCode,
+            fileContent: optinos.basicUITsCode,
         }, { cache: true });
+        // 带有类型的依赖库组件
+        await this.addFile({
+            file: 'extension.component.ts',
+            fileContent: optinos.withTypeLibraryTsCode,
+        }, { cache: true });
+        // 内置标准库类型
         Object.keys(naslStdlibMap_1.default).forEach(async (libFileName) => {
             await this.addFile({
                 file: `/${libFileName}`,
@@ -321,7 +328,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 self.file2NodeMap.set(result.filePath, node);
             }
             catch (err) {
-                if (utils.isDebugMode) {
+                if (process.env.NODE_ENV === 'development') {
                     self.logger.warn(node.nodePath ? node.nodePath : name, '代码转换失败', err);
                 }
             }
@@ -532,9 +539,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 await Promise.all(openFiles.map(async (file) => fs.outputFile(path.join(__dirname, '../debug/apps', app.id, file.file), file.fileContent)));
             }
             catch (e) {
-                if (utils.isDebugMode) {
-                    this.logger.error(e);
-                }
+                this.logger.error(e);
             }
         }
         /// #endif
@@ -639,6 +644,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
         const quickInfo = await this._getTypeQuickinfo({
             file: fileNode.getEmbeddedFilePath(),
             line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+            // TODO 适配依赖库的extension.xxx
             offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character) + `new nasl.ui.`.length,
         });
         if (quickInfo.responseRequired) {
@@ -1535,9 +1541,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                     jsCode = nodeIn.toJS();
                                 }
                                 catch (err) {
-                                    if (utils.isDebugMode) {
-                                        self.logger.error(err);
-                                    }
+                                    self.logger.error(err);
                                 }
                                 if (!jsCode.startsWith(`${node.name} = `))
                                     return;
@@ -1566,7 +1570,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                     const diagnostic = {
                                         node: nodeIn,
                                         severity: 'error',
-                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                        message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
                                     };
                                     nodeIn.tsErrorDetail = diagnostic;
                                     diagnostics.push(diagnostic);
@@ -2088,7 +2092,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                         const diagnostic = {
                                             node: nodeIn,
                                             severity: 'error',
-                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                            message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
                                         };
                                         nodeIn.tsErrorDetail = diagnostic;
                                         diagnostics.push(diagnostic);
@@ -2523,6 +2527,50 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             }
         }
+        if (node instanceof concepts_1.CallLogic) {
+            // 处理依赖库高阶函数，函数签名和函数调用参数要完全一一对应
+            if (node.calleeNamespace?.startsWith('extensions.')) {
+                const logicNode = node.getCallNode();
+                const params = logicNode?.params?.slice();
+                const findFunction = params.find(param => param?.typeAnnotation?.typeKind === 'function');
+                if (findFunction) {
+                    node.arguments?.forEach((argument, index) => {
+                        const expression = argument?.expression;
+                        const paramType = params[index]?.typeAnnotation;
+                        if (!expression?.tsErrorDetail && paramType?.typeKind === 'function' && paramType?.typeArguments?.length) {
+                            let hasLengthErrorDetail = {
+                                flag: false,
+                                message: '',
+                            };
+                            const isSubLogic = expression instanceof concepts_1.SubLogic;
+                            const isCallLogic = expression instanceof concepts_1.Identifier && expression?.namespace?.endsWith('logics');
+                            if (isSubLogic) {
+                                if (expression?.params?.length !== paramType.typeArguments.length) {
+                                    hasLengthErrorDetail.flag = true;
+                                    hasLengthErrorDetail.message = `高阶函数: 参数个数不匹配，期望 ${paramType.typeArguments.length} 个, 实际传入 ${expression.params?.length || 0} 个!`;
+                                }
+                            }
+                            else if (isCallLogic) {
+                                const getIdentCallLogic = expression.getFunctionCallNode();
+                                if (getIdentCallLogic?.params?.length !== paramType.typeArguments.length) {
+                                    hasLengthErrorDetail.flag = true;
+                                    hasLengthErrorDetail.message = `高阶函数: 参数个数不匹配，期望 ${paramType.typeArguments.length} 个, 实际传入 ${getIdentCallLogic.params?.length || 0} 个!`;
+                                }
+                            }
+                            if (hasLengthErrorDetail.flag) {
+                                const diagnostic = {
+                                    node: expression,
+                                    severity: 'error',
+                                    message: hasLengthErrorDetail.message,
+                                };
+                                expression.tsErrorDetail = diagnostic;
+                                diagnostics.push(diagnostic);
+                            }
+                        }
+                    });
+                }
+            }
+        }
         // if(node instanceof CallLogic) {
         //   const logic = node.getCallNode();
         //   const isElementLogic = node.calleeNamespace?.startsWith('elements.');
@@ -2910,9 +2958,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                         }
                     }
                     catch (e) {
-                        if (utils.isDebugMode) {
-                            this.logger.error('naslServer实体引用', e);
-                        }
+                        this.logger.error('naslServer实体引用', e);
                     }
                 }
             }
@@ -3332,9 +3378,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             }
                         }
                         catch (error) {
-                            if (utils.isDebugMode) {
-                                this.logger.error(error);
-                            }
+                            console.error(error);
                         }
                     }
                     else if (minRange.node instanceof concepts_1.Identifier) {
@@ -3673,6 +3717,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             App.emit('collect:start', {
                 actionMsg: '增加逻辑参数',
             });
+            console.log('-----增加逻辑参数-----');
             const index = node.getIndexOfParent();
             node.create({
                 index,
@@ -3681,6 +3726,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             });
             this._addParamsEffect(refsList, node);
             // 结束修改 ，批量操作
+            console.log('-----增加逻辑参数 结束-----');
             App.emit('collect:end');
             return node;
         }
@@ -3719,9 +3765,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
         }
         catch (err) {
-            if (utils.isDebugMode) {
-                this.logger.error(err);
-            }
+            this.logger.error(err);
         }
         return result;
     }
@@ -3746,9 +3790,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             });
         }
         catch (err) {
-            if (utils.isDebugMode) {
-                this.logger.error(err);
-            }
+            this.logger.error(err);
         }
         return [...result];
     }
@@ -4226,6 +4268,48 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 else {
                     // 清空原来已经赋值上去的类型，可能原来有现在没有了
                     delete node.__TypeAnnotation;
+                    // 给一些泛型标注的推导泛型
+                    delete node.__TypeArguments;
+                    /**
+                     * 特殊处理，calllogic 有泛型的情况，拿到的类型是错误的编译不出来的类型，所以要特殊处理一下
+                     * 不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
+                     */
+                    if (node instanceof concepts_1.CallLogic &&
+                        node.completeTypeParams?.length &&
+                        node?.__nodeType) {
+                        const logicNode = node.getCallNode();
+                        const autoTypeArguments = node.__nodeType?.typeArguments || [];
+                        const newAutoTypeArguments = [...autoTypeArguments];
+                        if (logicNode.returns?.length) {
+                            let returnType = newAutoTypeArguments.shift();
+                            if (node.handleError && returnType.typeName === 'Union') {
+                                const returnTypeArguments = returnType.typeArguments || [];
+                                const typeArguments = [...returnTypeArguments];
+                                const errorType = typeArguments.find((t) => t.typeName === 'Error');
+                                if (errorType) {
+                                    if (typeArguments.length === 2) {
+                                        returnType = typeArguments.filter((t) => t !== errorType)[0];
+                                    }
+                                    else {
+                                        returnType.typeArguments = typeArguments.filter((t) => t !== errorType);
+                                    }
+                                }
+                            }
+                            node.__TypeAnnotation = utils.runGeneratorSync((0, formatTsUtils_1.type2TypeAnnotation)(returnType));
+                        }
+                        const typeArgs = [];
+                        const typeArguments = node.typeArguments;
+                        node.completeTypeParams.forEach((typeArg, typeIndex) => {
+                            if (typeArg.needChoose) {
+                                typeArgs.push(typeArguments?.[typeIndex]);
+                            }
+                            else {
+                                const newType = utils.runGeneratorSync((0, formatTsUtils_1.type2TypeAnnotation)(newAutoTypeArguments.shift()));
+                                typeArgs.push(newType);
+                            }
+                        });
+                        node.__TypeArguments = typeArgs;
+                    }
                 }
             }
             catch (err) {
@@ -4264,8 +4348,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
         const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
         const json = app.toJSON();
         this.logger.timeEnd('全量标注');
-        // 测试环境或者是调试模式打印数据
-        if (utils.isDebugMode || utils.isTestBrowser) {
+        // 测试环境打印数据
+        if (utils.isTestBrowser) {
             this.logger.info('全量标注数据', json);
         }
         if (releaseFlag) {
@@ -4409,6 +4493,14 @@ let NaslServer = NaslServer_1 = class NaslServer {
                         node.arguments.pop();
                     }
                 }
+                /**
+                * 特殊处理，不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
+                */
+                if (node instanceof concepts_1.CallLogic && node.__TypeArguments?.length) {
+                    const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeArguments = node.__TypeArguments;
+                    jsonNode.typeAnnotation = node.__TypeAnnotation;
+                }
             }
             // 服务端需要默认值节点有类型来判断父节点是否是日期类型
             if (node instanceof concepts_1.DefaultValue && !value) {
@@ -4466,9 +4558,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
         }
         return new Promise((resolve, reject) => {
             const myTimer = setTimeout(() => {
-                if (utils.isDebugMode) {
-                    this.logger.warn(node, '没有获取到类型');
-                }
+                this.logger.warn(node, '没有获取到类型');
                 clearTimeout(myTimer);
                 clearInterval(mySetInterval);
                 if (node.__isCorrectTypeAnnotation) {