@lcap/nasl 3.12.0-rc.5 → 3.13.0-alpha.microapp-1

package/out/server/naslServer.js

@@ -34,15 +34,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var NaslServer_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NaslServer = exports.getDisplayString2Type = void 0;
-/// #if process.env.BUILD_TARGET === 'node'
-const fs = __importStar(require("fs-extra"));
-const path = __importStar(require("path"));
-const worker_threads_1 = require("worker_threads");
 const decimal_js_1 = require("decimal.js");
 const config_1 = require("../config");
 const nasl_sentry_1 = require("@lcap/nasl-sentry");
 const Messager_1 = __importDefault(require("../common/Messager"));
 const oql_cache_1 = require("./OQL/oql-cache");
+/// #if process.env.BUILD_TARGET === 'node'
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const worker_threads_1 = require("worker_threads");
+/// #endif
 const concepts_1 = require("../concepts");
 const asserts_1 = require("@lcap/nasl-concepts/asserts");
 const service_1 = require("@lcap/nasl-concepts/service");
@@ -175,7 +176,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
         this.changeStackList = [];
         // 包含组件逻辑调用的逻辑map
         this.logicSetWithComponentLogic = new Set();
-        this.isFirstScreen = true;
+        this.isFirstScreen = true; // 优化首屏 getAncestor 热点代码
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process)
             // For TS build
@@ -208,13 +209,16 @@ let NaslServer = NaslServer_1 = class NaslServer {
             getSender: () => this.worker,
             handleMessage: async ({ data }) => {
                 if (data && data.event === 'publishDiagnostics') {
-                    const records = await this._resolveDiagnosticRecords(data.records, data.versions);
-                    if (this.isFirstScreen) {
-                        await this.diagnosticManager.setInitialDiagData(records);
-                        this.isFirstScreen = false;
-                    }
-                    else {
-                        await this.diagnosticManager.pushAll(records);
+                    if (!this.isAnnotationMode) {
+                        const records = await this._resolveDiagnosticRecords(data.records, data.versions);
+                        if (this.isFirstScreen) {
+                            this.isFirstScreen = false;
+                            await this.diagnosticManager.setInitialDiagData(records);
+                            this.semData.calcAndSaveIndRetDepAndRevMap(this.tempApp.logics.map(this.toRaw));
+                        }
+                        else {
+                            await this.diagnosticManager.pushAll(records);
+                        }
                     }
                     try {
                         // 结束诊断和标注
@@ -285,7 +289,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
         return this.messager.requestCommand('start');
     }
     terminate() {
-        return this.worker.terminate();
+        this.worker.terminate();
+        this.worker = null;
     }
     async createUiTs(components, optinos) {
         const { standardUIComponents, // 标准组件（带有ts类型定义文件的组件）
@@ -307,7 +312,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             code = code.replace(extendsStringReg, ($0, $1, $2) => `extends nasl.core.StringLiteral<\`${$2}\`>`);
             return code;
         };
-        ///  process.env.BUILD_TARGET !== 'node'
+        /// #if process.env.BUILD_TARGET !== 'node'
         if (!utils.isNode) {
             await this.addFile({
                 file: 'nasl.ui.definition.ts',
@@ -352,7 +357,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
         });
         this.elementsLogic = elementsLogic;
     }
-    *contentToFile(module) {
+    *contentToFile(module1) {
+        // @ts-ignore
+        const module = module1.__v_raw ?? module1;
         if (!module) {
             return [];
         }
@@ -465,100 +472,92 @@ let NaslServer = NaslServer_1 = class NaslServer {
         }
         return results;
     }
-    redirectSlowGetters(app, varScopeCtx) {
-        Object.defineProperty(concepts_1.BaseNode.prototype, 'app', {
-            get() { return app; },
-            configurable: true,
-        });
-        Object.defineProperties(concepts_1.Identifier.prototype, {
-            isFrontendVariables: {
-                get() { return varScopeCtx.frontendGlobalVars.has(`${this.namespace}.${this.name}`); },
-                configurable: true,
-            },
-            view: {
-                get() { return varScopeCtx.idToView.get(this); },
-                configurable: true,
-            },
-            viewElement: {
-                get() { return varScopeCtx.idToViewElem.get(this); },
-                configurable: true,
-            },
-            businessComponent: {
-                get() { return varScopeCtx.idToBsComponent.get(this); },
-                configurable: true,
-            },
-            callLogic: {
-                get() { return varScopeCtx.idToCallLogic.get(this); },
-                configurable: true,
-            },
-            frontendType: {
-                get() { return varScopeCtx.idToFrontendType.get(this); },
-                configurable: true,
-            },
-            callQueryComponent: {
-                get() { return varScopeCtx.idToCallQueryComponent.get(this); },
-                configurable: true,
-            },
-        });
+    async requestDatabaseConfigs(http, app) {
+        const res = await http.get('/api/v1/app/config/list?category=sql');
+        const data = res.data?.result || [];
+        const map = data.filter((item) => item.category === 'sql' && item.available)
+            ?.reduce((acc, item) => ({
+            ...acc,
+            [item.configId]: item.configs?.type,
+        }), ({}));
+        app.saveDatabaseConfigIdToTypeMap(map);
     }
-    recoverSlowGetters() {
-        Object.defineProperty(concepts_1.BaseNode.prototype, 'app', {
-            get() { return this.getAncestor('App'); },
-            configurable: true,
+    async requestSqlFunctions(http, appName) {
+        const res = await http.get('/api/v1/app/config/database/functions');
+        const data = res.data?.result?.result || [];
+        const files = data
+            .filter((item) => !!item.signature)
+            .map((item) => {
+            return {
+                file: `/embedded/${appName}/sqlFunctions/${item.dbType}.ts`,
+                fileContent: item.signature.replace('declare namespace nasl.util', `declare namespace nasl.sqlFunction.${item.dbType}`),
+            };
         });
-        Object.defineProperties(concepts_1.Identifier.prototype, {
-            isFrontendVariables: {
-                get() {
-                    const self = this.__v_raw ?? this;
-                    const frontendType = self.getAncestor('FrontendType');
-                    return (self.namespace?.startsWith(`app.frontendTypes.${frontendType?.kind}.frontends`) &&
-                        self.namespace?.endsWith('variables'));
-                },
-                configurable: true,
-            },
-            view: {
-                get() { return this.getAncestor('View'); },
-                configurable: true,
-            },
-            viewElement: {
-                get() { return this.getAncestor('ViewElement'); },
-                configurable: true,
-            },
-            businessComponent: {
-                get() { return this.getAncestor('BusinessComponent'); },
-                configurable: true,
-            },
-            callLogic: {
-                get() { return this.getAncestor('CallLogic'); },
-                configurable: true,
-            },
-            frontendType: {
-                get() { return this.getAncestor('FrontendType'); },
-                configurable: true,
-            },
-            callQueryComponent: {
-                get() { return this.getAncestor('CallQueryComponent'); },
-                configurable: true,
-            },
+        data.forEach((item) => {
+            delete item.signature;
         });
+        this._sqlFunctions = data;
+        return files;
+    }
+    getSqlFunctions(dbType) {
+        const res = this._sqlFunctions.find((f) => f.dbType === dbType);
+        if (res) {
+            res.functions.forEach((func) => {
+                func.expanded = true;
+            });
+        }
+        return res;
+    }
+    getSqlFunction(dbType, functionName) {
+        if (!functionName)
+            return null;
+        const sqlFunction = this.getSqlFunctions(dbType);
+        if (!sqlFunction)
+            return null;
+        const upperFunctionName = functionName.toUpperCase();
+        for (const category of sqlFunction.functions) {
+            for (const func of category.children) {
+                if (func.name === upperFunctionName) {
+                    return func;
+                }
+            }
+        }
+        return null;
     }
     async openApp(app, performance = false, needRegisterCommand = true) {
         app.naslServer = this;
+        this.tempApp = app; // IDE 加载临时使用，诊断信息处理完回设置为 undefined，不要在其他地方使用了，避免循环引用。
         if (utils.isAutoTestEnv) {
             this.logger.info('运行在自动化测试模式下...');
         }
         this.logger.time('全量生成并写入 TS 文件——总计');
+        const toEmbeddedTSStartTime = new Date().getTime();
         this.logger.time('全量生成 TS——翻译');
         this.logger.time('全量生成 TS——翻译——简单语义分析');
         this.semData = new nasl_concepts_1.SemanticData();
         // 除此之外，好像没什么简单的方法可以让 __xxx.ts 文件快速拿到 app.naslServer 的引用了……
-        this.redirectSlowGetters(app, this.semData.varScopeCtx);
-        this.semData.collectAllSemanticCtx(app);
+        // @ts-ignore
+        this.semData.redirectSlowGetters(app.__v_raw ?? app, this.semData.varScopeCtx);
+        // @ts-ignore
+        this.semData.collectAllSemanticCtx(app.__v_raw ?? app);
         // semantics.printSemanticDataInfo();
         this.logger.timeEnd('全量生成 TS——翻译——简单语义分析');
         (0, common_1.invokeCommand)('naslServer:startWork');
         const self = this;
         this.performance = performance;
+        try {
+            await this.requestDatabaseConfigs(this.http, app);
+        }
+        catch (err) {
+            this.logger.error('请求数据库配置列表失败', err);
+        }
+        let sqlSignatureFiles = [];
+        try {
+            sqlSignatureFiles = await this.requestSqlFunctions(this.http, app.name);
+        }
+        catch (err) {
+            this.logger.error('请求sql函数列表失败', err);
+        }
         const results = await utils.runGeneratorAsync(getAllTsFiles());
         const files = results.map((result) => ({
             file: result.filePath,
@@ -570,6 +569,10 @@ let NaslServer = NaslServer_1 = class NaslServer {
         files.forEach((f) => {
             this.diagnosticManager.deleteVersionByFilePath(f.file);
         });
+        // 添加 sql 函数签名文件
+        sqlSignatureFiles.forEach((sqlFunction) => {
+            files.push(sqlFunction);
+        });
         await this.writeFiles(files);
         this._debugInFileStorage(app, files);
         if (needRegisterCommand) {
@@ -585,9 +588,13 @@ let NaslServer = NaslServer_1 = class NaslServer {
             });
         }
         this.logger.timeEnd('全量生成 TS——写入文件');
-        this.recoverSlowGetters();
+        this.semData.recoverSlowGetters();
         this.semData.clearSemanticData();
         this.logger.timeEnd('全量生成并写入 TS 文件——总计');
+        const toEmbeddedTSEndTime = new Date().getTime();
+        const toEmbeddedTSUsedTime = toEmbeddedTSEndTime - toEmbeddedTSStartTime;
+        app.naslServer.appPerfermenceData = app.naslServer.appPerfermenceData || {};
+        app.naslServer.appPerfermenceData.toEmbeddedTSUsedTime = toEmbeddedTSUsedTime;
         function* getAllTsFiles() {
             const files = yield* self.contentToFile(app);
             const otherModules = [
@@ -606,7 +613,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             return files;
         }
     }
-    async refreshApp(app) {
+    async refreshApp(app, performance) {
         // 清除所有问题
         this.diagnosticManager.clear();
         // 刷新要清除文件列表
@@ -614,8 +621,12 @@ let NaslServer = NaslServer_1 = class NaslServer {
         await this.deleteDirectoryFiles({ directoryName: '/embedded' });
         // 清楚check count的数量
         await this.messager.requestCommand('_clearTimeout');
+        // 如果没传就用当前this的
+        if (performance === undefined) {
+            performance = this.performance;
+        }
         // 重新加载app下内容
-        await this.openApp(app, this.performance);
+        await this.openApp(app, performance);
         // 重新check一遍所有内容
         await this.getDiagnosticRecordsAndPushAll();
         // check内容后，会自动走增量类型标注完善全部类型
@@ -990,13 +1001,14 @@ let NaslServer = NaslServer_1 = class NaslServer {
             });
             record.semanticDiagnostics = (yield* utils.wrapMapToGenerator(record.semanticDiagnostics, diag => self._resolveSingleDiagnostic(diag, node, record))).filter((diag) => !!diag);
             record.semanticDiagnostics.push(...(yield* self._attachDiagnosticsWithGenerator(node)));
+            let sugDiag = [];
             // 报错降级逻辑
             record.semanticDiagnostics = (yield* utils.wrapMapToGenerator(record.semanticDiagnostics, (diag) => {
                 // 错误降级如果属于草稿态的就降级
                 if (diag?.node) {
                     let currentNode = diag.node;
                     if (diag.severity === 'warning') {
-                        record.suggestionDiagnostics.push(diag);
+                        sugDiag.push(diag);
                         return null;
                     }
                     if (concepts_1.asserts.isStrictOqlQueryComponent(currentNode)) {
@@ -1008,7 +1020,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                 // 重置组件节点上的错误信息
                                 diag.node.tsErrorDetail.severity = 'warning';
                             }
-                            record.suggestionDiagnostics.push(diag);
+                            sugDiag.push(diag);
                             return null;
                         }
                     }
@@ -1027,7 +1039,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                 // 重置组件节点上的错误信息
                                 diag.node.tsErrorDetail.severity = 'warning';
                             }
-                            record.suggestionDiagnostics.push(diag);
+                            sugDiag.push(diag);
                             return null;
                         }
                     }
@@ -1040,7 +1052,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                 // 重置组件节点上的错误信息
                                 diag.node.tsErrorDetail.severity = 'warning';
                             }
-                            record.suggestionDiagnostics.push(diag);
+                            sugDiag.push(diag);
                             return null;
                         }
                         currentNode = currentNode.parentNode;
@@ -1054,7 +1066,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 return diag;
             })).filter((diag) => !!diag);
             // 处理后的警告异常提示信息
-            record.suggestionDiagnostics = (yield* utils.wrapMapToGenerator(record.suggestionDiagnostics, function* resolveSuggestionDiagnostic(diag) {
+            sugDiag = (yield* utils.wrapMapToGenerator(sugDiag, function* resolveSuggestionDiagnostic(diag) {
                 // 上面错误降级下来的
                 if (diag?.node) {
                     return diag;
@@ -1112,7 +1124,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 return null;
             }))
                 .filter((diag) => !!diag);
-            record.suggestionDiagnostics.push(...yield* self._attachSuggestionDiagnosticsWithGenerator(node));
+            sugDiag.push(...yield* self._attachSuggestionDiagnosticsWithGenerator(node));
+            record.suggestionDiagnostics = sugDiag;
         });
         this.logger.timeEnd('处理诊断数据');
         this.logger.timeEnd('语言服务变更');
@@ -1669,6 +1682,14 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             }
                         });
                     }
+                    if (node._foldInView) {
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: `组件${node.name}已经极速折叠`,
+                        };
+                        diagnostics.push(diagnostic);
+                    }
                 }
                 else if ((node instanceof concepts_1.Variable || node instanceof concepts_1.Return) && cmpFileNode(fileNode, fileNodeRaw, likeComponent)) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
@@ -4581,6 +4602,23 @@ let NaslServer = NaslServer_1 = class NaslServer {
             });
         }
     }
+    getSlotCurrentCompletion(node) {
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (currentSource && fileNode) {
+            const range = {
+                line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+            };
+            if (['BindAttribute', 'BindDirective', 'BindStyle'].includes(node.concept)) {
+                range.line = (0, translator_1.lsp2tspNumber)(currentSource.end.line);
+                range.offset = 1;
+            }
+            return this.messager.requestCommand('getSlotCurrentCompletion', {
+                file: fileNode.getEmbeddedFilePath(),
+                range
+            });
+        }
+    }
     _getFieldKeySelectCompletion(args) {
         return this.messager.requestCommand('getFieldKeySelectCompletion', args);
     }
@@ -4729,7 +4767,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
             // 如果 入参不是虚拟节点的，就不去请求类型
             // 只有虚拟节点的入参，才没有类型
-            if (node.concept === 'Param' && (node.parentKey !== 'virtualParams' && node.parentKey !== 'item' && node.parentNode.concept !== 'AnonymousFunction')) {
+            if (node.concept === 'Param' &&
+                (node.parentKey !== 'virtualParams' && node.parentKey !== 'item' && node.parentNode.concept !== 'AnonymousFunction')) {
                 return;
             }
             if (![
@@ -4831,7 +4870,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
             else if (node instanceof concepts_1.Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
-                const argType = yield* self.getArgumentTypeAnnotationWithGenerator(node, newQuickInfoNodes, types);
+                const argType = yield* self.getArgumentTypeAnnotationWithGenerator(node, types);
                 types.set(node, argType);
             }
             else if (node instanceof concepts_1.MatchCase) {
@@ -4845,14 +4884,14 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             }
         });
-        yield* utils.wrapIteratorToGenerator(types.entries(), ([node, value]) => {
+        yield* utils.wrapIteratorToGenerator(types.entries(), ([node, ty]) => {
             try {
                 // 因为node可能是经过处理的TypeAnnotation
                 node.__isCorrectTypeAnnotation = true;
-                if (value) {
+                if (ty) {
                     if (node instanceof concepts_1.OqlQueryComponent) {
                         // 自动推导情况
-                        const typeAnnotation = value;
+                        const typeAnnotation = ty;
                         if (!node.typeAnnotation && typeAnnotation) {
                             if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
                                 const { typeArguments } = typeAnnotation;
@@ -4863,11 +4902,11 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             }
                         }
                     }
-                    if (value instanceof concepts_1.TypeAnnotation) {
-                        node.__TypeAnnotation = value;
+                    if (ty instanceof concepts_1.TypeAnnotation) {
+                        node.__TypeAnnotation = ty;
                     }
-                    else if (value.typeAnnotation) {
-                        node.__TypeAnnotation = value.typeAnnotation;
+                    else if (ty.typeAnnotation) {
+                        node.__TypeAnnotation = ty.typeAnnotation;
                     }
                     // 节点有函数返回时候 返回类型作为typeAnnotation
                     const nodeType = node.__nodeType;
@@ -4909,9 +4948,6 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             }
             catch (err) {
-                // if (globalThis.window) {
-                //   this.logger.info(err);
-                // }
             }
         });
         // 预留时间做 minor gc，减少峰值内存占用
@@ -4996,11 +5032,11 @@ let NaslServer = NaslServer_1 = class NaslServer {
         const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
         this.logger.time('app to AnnotatedJSON');
         const jsonMap = new Map();
-        const json = naslNode._toJSON((source, instance) => {
+        const json = naslNode._toJSON((newJson, oldNode) => {
             // 删除多余属性，降低全量数据
-            delete source._aiUID;
-            jsonMap.set(instance, source);
-            return source;
+            delete newJson._aiUID;
+            jsonMap.set(oldNode, newJson);
+            return newJson;
         });
         this.logger.timeEnd('app to AnnotatedJSON');
         this.logger.timeEnd(`${isApp ? '全量' : '单文件'}标注`);
@@ -5011,66 +5047,215 @@ let NaslServer = NaslServer_1 = class NaslServer {
         if (releaseFlag) {
             this.logger.time('annotationToJson');
             // 全量标注后对json进行一些修改，为了服务端翻译处理
-            this.annotationToJson(typesMap, json, jsonMap);
+            this.annotationToJson(typesMap, jsonMap); // 把 typesMap 里的类型写入 jsonMap 的 node.typeAnnotation 里
             this.logger.timeEnd('annotationToJson');
         }
         return json;
     }
-    // 全量标注并且返回json，用 generator
-    *getNaslAnnotatedJSONWithGenerator(naslNode, releaseFlag) {
+    // 不用 TS LS 的最新类型，用现有类型直接写入 NASL json
+    async fastGetNaslAnnotatedJSON(naslNode) {
         // eslint-disable-next-line @typescript-eslint/no-shadow
         const isApp = concepts_1.asserts.isApp(naslNode);
         if (this.changeStackList?.length) {
             throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作`);
         }
-        this.logger.time(`${isApp ? '全量' : '单文件'}标注`);
-        const nodes = [];
-        if (!isApp) {
-            const filePath = naslNode?.getEmbeddedFilePath();
-            naslNode.sourceMap?.forEach?.((item, node) => {
-                nodes.push({
-                    filePath,
-                    node,
-                    item,
-                });
-            });
-        }
-        else {
-            this.file2NodeMap.forEach((fileNode, filePath) => {
-                // 先不排除view，传递给后端的时候，去除views下的标注
-                if (!(0, service_1.isIgnoreFullAnnotationFileNode)(fileNode)) {
-                    fileNode.sourceMap.forEach((item, node) => {
-                        nodes.push({
-                            filePath,
-                            node,
-                            item,
-                        });
-                    });
-                }
-            });
-        }
-        const typesMap = yield* this._getQuickInfoNodesTypeMapWithGenerator(nodes);
         this.logger.time('app to AnnotatedJSON');
-        const jsonMap = new Map();
-        // @ts-ignore
-        const json = yield* naslNode._toJSONWithGenerator((source, instance) => {
+        const timeZoneArgumentIndexMap = new Map([
+            ['ToString', 1],
+            ['CurrDateTime', 0],
+            ['CurrDate', 0],
+            ['CurrTime', 0],
+            ['FormatDateTime', 2],
+            ['jsonSerialize', 1],
+            ['GetDateCount', 2],
+            ['GetSpecificDaysOfWeek', 3]
+        ]);
+        const tyAnnToJSON = (nd) => nd ? (nd.toJSON?.() ?? nd) : null;
+        const longTyAnn = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
+        const json = this.toRaw(naslNode)._toJSON((newJson, oldNd) => {
             // 删除多余属性，降低全量数据
-            delete source._aiUID;
-            jsonMap.set(instance, source);
-            return source;
+            delete newJson._aiUID; // @ts-ignore
+            let tyAnn = tyAnnToJSON(oldNd.__TypeAnnotation);
+            // 原来的标注环节复制粘贴过来改写的
+            {
+                // 如果节点本身有类型就不去在塞一遍了
+                // 有值而且没有类型再去设置
+                // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
+                if (tyAnn && (oldNd instanceof concepts_1.Argument) && oldNd.getAncestor('Connector')?.concept === 'Connector') { // @ts-ignore
+                    newJson.typeAnnotation = tyAnn;
+                }
+                if (tyAnn && (!oldNd.typeAnnotation || oldNd instanceof concepts_1.Identifier || oldNd instanceof concepts_1.MemberExpression)) { // @ts-ignore
+                    newJson.typeAnnotation = tyAnn;
+                }
+                // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
+                if (oldNd instanceof concepts_1.CallQueryComponent && !oldNd.isAutoInfer()) { // @ts-ignore
+                    newJson.typeAnnotation = {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'anonymousStructure',
+                        typeNamespace: null,
+                        typeName: null,
+                        typeArguments: [],
+                        inferred: false,
+                        ruleMap: null,
+                        properties: [
+                            {
+                                concept: 'StructureProperty',
+                                name: 'list',
+                                label: null,
+                                description: null,
+                                typeAnnotation: {
+                                    concept: 'TypeAnnotation',
+                                    typeKind: 'generic',
+                                    typeNamespace: 'nasl.collection',
+                                    typeName: 'List', // @ts-ignore
+                                    typeArguments: [newJson.typeAnnotation],
+                                    inferred: null,
+                                },
+                                required: null,
+                                defaultValue: null,
+                            },
+                            {
+                                concept: 'StructureProperty',
+                                name: 'total',
+                                label: null,
+                                description: null,
+                                typeAnnotation: {
+                                    concept: 'TypeAnnotation',
+                                    typeKind: 'primitive',
+                                    typeNamespace: 'nasl.core',
+                                    typeName: 'Long',
+                                    typeArguments: null,
+                                    inferred: null,
+                                },
+                                required: null,
+                                defaultValue: null,
+                            },
+                        ],
+                    };
+                }
+                // 特殊处理param有类型错误的
+                if (tyAnn && oldNd instanceof concepts_1.Param) {
+                    // index在nasl foreach上有脏数据
+                    if (oldNd.parentKey === 'index' && oldNd.parentNode instanceof concepts_1.ForEachStatement) { // @ts-ignore
+                        newJson.typeAnnotation = longTyAnn;
+                    }
+                }
+                if (oldNd instanceof concepts_1.Match) {
+                    const matchExpression = oldNd.expression;
+                    if (matchExpression?.__TypeAnnotation?.typeKind === 'union' &&
+                        (matchExpression instanceof concepts_1.Identifier || matchExpression instanceof concepts_1.MemberExpression)) {
+                        const { currentSource, fileNode } = matchExpression?.getCurrentSource();
+                        const currentCode = this.getNodeCode(fileNode, currentSource);
+                        fileNode.sourceMap.forEach((item, itemNode) => {
+                            const itemCode = this.getNodeCode(fileNode, item);
+                            if (itemNode.concept === matchExpression.concept && itemCode === currentCode) { // @ts-ignore
+                                newJson.typeAnnotation = matchExpression.__TypeAnnotation;
+                            }
+                        });
+                    }
+                }
+                // 特殊处理param有类型错误的
+                if (tyAnn && (oldNd instanceof concepts_1.Param)) {
+                    // index在nasl foreach上有脏数据
+                    if (oldNd.parentKey === 'index' && oldNd.parentNode instanceof concepts_1.ForEachStatement) { // @ts-ignore
+                        newJson.typeAnnotation = tyAnn;
+                    }
+                }
+                if (tyAnn && (oldNd instanceof concepts_1.NewComposite) &&
+                    (oldNd.typeAnnotation?.typeKind === 'anonymousStructure' || oldNd.typeAnnotation?.typeKind === 'generic')) { // @ts-ignore
+                    newJson.typeAnnotation = tyAnn;
+                }
+                // jsonSerializer 是 CallLogic，其余是 CallFunction
+                if (oldNd instanceof concepts_1.CallFunction || oldNd instanceof concepts_1.CallLogic) {
+                    const tzArgIdx = timeZoneArgumentIndexMap.get(oldNd.calleeName);
+                    const args = oldNd.arguments;
+                    const tzArg = args ? args[tzArgIdx] : undefined;
+                    if (tzArgIdx && tzArg?.keyword === '时区' && !isCoreDateTimeType(oldNd.arguments[0])) {
+                        if (!isFunctionWithFixedTimeZoneParam(oldNd.calleeName)) {
+                            oldNd.arguments.pop();
+                        }
+                    }
+                    /**
+                    * 特殊处理，不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
+                    */
+                    if (oldNd instanceof concepts_1.CallLogic && oldNd.__TypeArguments?.length) { // @ts-ignore
+                        newJson.typeArguments = oldNd.__TypeArguments.map(tyAnnToJSON); // @ts-ignore
+                        newJson.typeAnnotation = tyAnn;
+                    }
+                    // 根据 https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2737356895760128&id1=null&iterationId=null&versionid=null&tab=info
+                    // 对CallFunction节点，若其callee为部分List/Map内置函数，则修改其argument类型标注以让服务端据此插入显式的类型转换。规则如下：
+                    // - 对argument.expression.typeAnnotation 无需做修改，保持为其实际类型
+                    // - 对argument.typeAnnotation，为根据对应Collection的泛型参数的类型填写其类型
+                    if (newJson.concept === 'CallFunction') {
+                        if (oldNd.calleeNamespace === 'nasl.util') {
+                            const calleeName = oldNd.calleeName;
+                            const listFunctionParamIndexMaps = new Map(Object.entries({
+                                Add: { collection: 0, item: 1 },
+                                Insert: { collection: 0, item: 2 },
+                                Remove: { collection: 0, item: 1 },
+                                Contains: { collection: 0, item: 1 },
+                            }));
+                            const mapFunctionParamIndexMaps = new Map(Object.entries({
+                                MapPut: { collection: 0, key: 1, value: 2 },
+                                MapGet: { collection: 0, key: 1, },
+                                MapRemove: { collection: 0, key: 1 },
+                                MapContains: { collection: 0, key: 1 },
+                            }));
+                            const listParamIndex = listFunctionParamIndexMaps.get(calleeName);
+                            if (listParamIndex) {
+                                const list = newJson.arguments[listParamIndex.collection];
+                                const item = newJson.arguments[listParamIndex.item];
+                                const itemExpression = item?.expression;
+                                if (itemExpression) {
+                                    const listTypeArgument = tyAnnToJSON(list.__TypeAnnotation?.typeArguments?.[0]);
+                                    if (listTypeArgument) {
+                                        newJson.typeAnnotation = listTypeArgument;
+                                    }
+                                }
+                            }
+                            else {
+                                const mapParamIndex = mapFunctionParamIndexMaps.get(calleeName);
+                                if (mapParamIndex) {
+                                    const map = newJson.arguments[mapParamIndex.collection];
+                                    const key = newJson.arguments[mapParamIndex.key];
+                                    const value = newJson.arguments[mapParamIndex.value];
+                                    const keyExpression = key?.expression;
+                                    const valueExpression = value?.expression;
+                                    if (keyExpression) {
+                                        const mapKeyTypeArgument = tyAnnToJSON(map.__TypeAnnotation?.typeArguments?.[0]);
+                                        if (mapKeyTypeArgument) {
+                                            const kJson = newJson.arguments[mapParamIndex.key];
+                                            kJson.typeAnnotation = mapKeyTypeArgument;
+                                        }
+                                    }
+                                    if (valueExpression) {
+                                        const mapValueTypeArgument = tyAnnToJSON(map.__TypeAnnotation?.typeArguments?.[1]);
+                                        if (mapValueTypeArgument) {
+                                            const vJson = newJson.arguments[mapParamIndex.value];
+                                            vJson.typeAnnotation = mapValueTypeArgument;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                // 服务端需要默认值节点有类型来判断父节点是否是日期类型
+                if (newJson.concept === 'DefaultValue' && !tyAnn) {
+                    const parentNodeType = oldNd.parentNode?.typeAnnotation || oldNd.parentNode?.__TypeAnnotation;
+                    if (parentNodeType) { // @ts-ignore
+                        newJson.typeAnnotation = tyAnnToJSON(parentNodeType);
+                    }
+                }
+            }
+            ;
+            return newJson;
         });
         this.logger.timeEnd('app to AnnotatedJSON');
-        this.logger.timeEnd(`${isApp ? '全量' : '单文件'}标注`);
         // 测试环境或者是调试模式打印数据
         if (utils.isDebugMode || utils.isTestBrowser) {
             this.logger.info(`${isApp ? '全量' : '单文件'}标注数据`, json);
         }
-        if (releaseFlag) {
-            this.logger.time('annotationToJsonWithGenerator');
-            // 全量标注后对json进行一些修改，为了服务端翻译处理
-            yield* this.annotationToJsonWithGenerator(typesMap, json, jsonMap);
-            this.logger.timeEnd('annotationToJsonWithGenerator');
-        }
         return json;
     }
     /**
@@ -5124,7 +5309,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
         yield* this._getQuickInfoNodesTypeMapWithGenerator(nodes);
         this.logger.timeEnd('增量标注');
     }
-    annotationToJson(typesMap, json, jsonMap) {
+    annotationToJson(typesMap, jsonMap) {
         const timeZoneArgumentIndexMap = new Map([
             ['ToString', 1],
             ['CurrDateTime', 0],
@@ -5135,26 +5320,26 @@ let NaslServer = NaslServer_1 = class NaslServer {
             ['GetDateCount', 2],
             ['GetSpecificDaysOfWeek', 3]
         ]);
-        typesMap.forEach((value, node) => {
+        typesMap.forEach((typ, node) => {
             // 如果节点本身有类型就不去在塞一遍了
             // 有值而且没有类型再去设置
             // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
-            if (value && (node instanceof concepts_1.Argument) && node.getAncestor('Connector')?.concept === 'Connector') {
-                const jsonNode = jsonMap.get(node);
-                if (jsonNode) {
-                    jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
+            if (typ && (node instanceof concepts_1.Argument) && node.getAncestor('Connector')?.concept === 'Connector') {
+                const newJson = jsonMap.get(node);
+                if (newJson) {
+                    newJson.typeAnnotation = typ?.toJSON?.() ?? typ;
                 }
             }
-            if (value && (!node.typeAnnotation || node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression)) {
-                const jsonNode = jsonMap.get(node);
-                if (jsonNode) {
-                    jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
+            if (typ && (!node.typeAnnotation || node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression)) {
+                const newJson = jsonMap.get(node);
+                if (newJson) {
+                    newJson.typeAnnotation = typ?.toJSON?.() ?? typ;
                 }
             }
             // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
             if (node instanceof concepts_1.CallQueryComponent && !node.isAutoInfer()) {
-                const jsonNode = jsonMap.get(node);
-                jsonNode.typeAnnotation = {
+                const newJson = jsonMap.get(node);
+                newJson.typeAnnotation = {
                     concept: 'TypeAnnotation',
                     typeKind: 'anonymousStructure',
                     typeNamespace: null,
@@ -5173,7 +5358,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                 typeKind: 'generic',
                                 typeNamespace: 'nasl.collection',
                                 typeName: 'List',
-                                typeArguments: [jsonNode.typeAnnotation],
+                                typeArguments: [newJson.typeAnnotation],
                                 inferred: null,
                             },
                             required: null,
@@ -5202,8 +5387,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
             if (node instanceof concepts_1.Param) {
                 // index在nasl foreach上有脏数据
                 if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
-                    const jsonNode = jsonMap.get(node);
-                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
+                    const newJson = jsonMap.get(node);
+                    newJson.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
                 }
             }
             if (node instanceof concepts_1.Match) {
@@ -5215,23 +5400,23 @@ let NaslServer = NaslServer_1 = class NaslServer {
                     fileNode.sourceMap.forEach((item, itemNode) => {
                         const itemCode = this.getNodeCode(fileNode, item);
                         if (itemNode.concept === matchExpression.concept && itemCode === currentCode) {
-                            const jsonNode = jsonMap.get(itemNode);
-                            jsonNode.typeAnnotation = matchExpression.__TypeAnnotation;
+                            const newJson = jsonMap.get(itemNode);
+                            newJson.typeAnnotation = matchExpression.__TypeAnnotation;
                         }
                     });
                 }
             }
             // 特殊处理param有类型错误的
-            if (value && (node instanceof concepts_1.Param)) {
+            if (typ && (node instanceof concepts_1.Param)) {
                 // index在nasl foreach上有脏数据
                 if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
-                    const jsonNode = jsonMap.get(node);
-                    jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
+                    const newJson = jsonMap.get(node);
+                    newJson.typeAnnotation = typ?.toJSON?.() ?? typ;
                 }
             }
-            if (value && (node instanceof concepts_1.NewComposite) && (node.typeAnnotation?.typeKind === 'anonymousStructure' || node.typeAnnotation?.typeKind === 'generic')) {
-                const jsonNode = jsonMap.get(node);
-                jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
+            if (typ && (node instanceof concepts_1.NewComposite) && (node.typeAnnotation?.typeKind === 'anonymousStructure' || node.typeAnnotation?.typeKind === 'generic')) {
+                const newJson = jsonMap.get(node);
+                newJson.typeAnnotation = typ?.toJSON?.() ?? typ;
             }
             // jsonSerializer 是 CallLogic，其余是 CallFunction
             if (node instanceof concepts_1.CallFunction || node instanceof concepts_1.CallLogic) {
@@ -5247,9 +5432,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 * 特殊处理，不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
                 */
                 if (node instanceof concepts_1.CallLogic && node.__TypeArguments?.length) {
-                    const jsonNode = jsonMap.get(node);
-                    jsonNode.typeArguments = node.__TypeArguments.map((type) => type?.toJSON?.() ?? type);
-                    jsonNode.typeAnnotation = node.__TypeAnnotation?.toJSON?.() ?? node.__TypeAnnotation;
+                    const newJson = jsonMap.get(node);
+                    newJson.typeArguments = node.__TypeArguments.map((type) => type?.toJSON?.() ?? type);
+                    newJson.typeAnnotation = node.__TypeAnnotation?.toJSON?.() ?? node.__TypeAnnotation;
                 }
                 // 根据 https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2737356895760128&id1=null&iterationId=null&versionid=null&tab=info
                 // 对CallFunction节点，若其callee为部分List/Map内置函数，则修改其argument类型标注以让服务端据此插入显式的类型转换。规则如下：
@@ -5278,8 +5463,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             if (itemExpression) {
                                 const listTypeArgument = list.__TypeAnnotation?.typeArguments?.[0]?.toJSON?.() ?? list.__TypeAnnotation?.typeArguments?.[0];
                                 if (listTypeArgument) {
-                                    const jsonNode = jsonMap.get(item);
-                                    jsonNode.typeAnnotation = listTypeArgument;
+                                    const newJson = jsonMap.get(item);
+                                    newJson.typeAnnotation = listTypeArgument;
                                 }
                             }
                         }
@@ -5294,15 +5479,15 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                 if (keyExpression) {
                                     const mapKeyTypeArgument = map.__TypeAnnotation?.typeArguments?.[0]?.toJSON?.() ?? map.__TypeAnnotation?.typeArguments?.[0];
                                     if (mapKeyTypeArgument) {
-                                        const jsonNode = jsonMap.get(key);
-                                        jsonNode.typeAnnotation = mapKeyTypeArgument;
+                                        const newJson = jsonMap.get(key);
+                                        newJson.typeAnnotation = mapKeyTypeArgument;
                                     }
                                 }
                                 if (valueExpression) {
                                     const mapValueTypeArgument = map.__TypeAnnotation?.typeArguments?.[1]?.toJSON?.() ?? map.__TypeAnnotation?.typeArguments?.[1];
                                     if (mapValueTypeArgument) {
-                                        const jsonNode = jsonMap.get(value);
-                                        jsonNode.typeAnnotation = mapValueTypeArgument;
+                                        const newJson = jsonMap.get(value);
+                                        newJson.typeAnnotation = mapValueTypeArgument;
                                     }
                                 }
                             }
@@ -5311,218 +5496,21 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             }
             // 服务端需要默认值节点有类型来判断父节点是否是日期类型
-            if (node instanceof concepts_1.DefaultValue && !value) {
-                const jsonNode = jsonMap.get(node);
+            if (node instanceof concepts_1.DefaultValue && !typ) {
+                const newJson = jsonMap.get(node);
                 const parentNodeType = node.parentNode?.typeAnnotation || node.parentNode?.__TypeAnnotation;
-                if (parentNodeType && jsonNode) {
-                    jsonNode.typeAnnotation = parentNodeType?.toJSON?.() ?? parentNodeType;
+                if (parentNodeType && newJson) {
+                    newJson.typeAnnotation = parentNodeType?.toJSON?.() ?? parentNodeType;
                 }
             }
         });
     }
-    *annotationToJsonWithGenerator(typesMap, json, jsonMap) {
-        const timeZoneArgumentIndexMap = new Map([
-            ['ToString', 1],
-            ['CurrDateTime', 0],
-            ['CurrDate', 0],
-            ['CurrTime', 0],
-            ['FormatDateTime', 2],
-            ['jsonSerialize', 1],
-            ['GetDateCount', 2],
-            ['GetSpecificDaysOfWeek', 3]
-        ]);
-        for (const [node, value] of typesMap) {
-            // 如果节点本身有类型就不去在塞一遍了
-            // 有值而且没有类型再去设置
-            // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
-            if (value && (node instanceof concepts_1.Argument) && node.getAncestor('Connector')?.concept === 'Connector') {
-                const jsonNode = jsonMap.get(node);
-                if (jsonNode) {
-                    jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
-                }
-            }
-            if (value && (!node.typeAnnotation || node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression)) {
-                const jsonNode = jsonMap.get(node);
-                if (jsonNode) {
-                    jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
-                }
-            }
-            // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
-            if (node instanceof concepts_1.CallQueryComponent && !node.isAutoInfer()) {
-                const jsonNode = jsonMap.get(node);
-                jsonNode.typeAnnotation = {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'anonymousStructure',
-                    typeNamespace: null,
-                    typeName: null,
-                    typeArguments: [],
-                    inferred: false,
-                    ruleMap: null,
-                    properties: [
-                        {
-                            concept: 'StructureProperty',
-                            name: 'list',
-                            label: null,
-                            description: null,
-                            typeAnnotation: {
-                                concept: 'TypeAnnotation',
-                                typeKind: 'generic',
-                                typeNamespace: 'nasl.collection',
-                                typeName: 'List',
-                                typeArguments: [jsonNode.typeAnnotation],
-                                inferred: null,
-                            },
-                            required: null,
-                            defaultValue: null,
-                        },
-                        {
-                            concept: 'StructureProperty',
-                            name: 'total',
-                            label: null,
-                            description: null,
-                            typeAnnotation: {
-                                concept: 'TypeAnnotation',
-                                typeKind: 'primitive',
-                                typeNamespace: 'nasl.core',
-                                typeName: 'Long',
-                                typeArguments: null,
-                                inferred: null,
-                            },
-                            required: null,
-                            defaultValue: null,
-                        },
-                    ],
-                };
-            }
-            // 特殊处理param有类型错误的
-            if (node instanceof concepts_1.Param) {
-                // index在nasl foreach上有脏数据
-                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
-                    const jsonNode = jsonMap.get(node);
-                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
-                }
-            }
-            if (node instanceof concepts_1.Match) {
-                const matchExpression = node.expression;
-                if (matchExpression?.__TypeAnnotation?.typeKind === 'union' &&
-                    (matchExpression instanceof concepts_1.Identifier || matchExpression instanceof concepts_1.MemberExpression)) {
-                    const { currentSource, fileNode } = matchExpression?.getCurrentSource();
-                    const currentCode = this.getNodeCode(fileNode, currentSource);
-                    fileNode.sourceMap.forEach((item, itemNode) => {
-                        const itemCode = this.getNodeCode(fileNode, item);
-                        if (itemNode.concept === matchExpression.concept && itemCode === currentCode) {
-                            const jsonNode = jsonMap.get(itemNode);
-                            jsonNode.typeAnnotation = matchExpression.__TypeAnnotation;
-                        }
-                    });
-                }
-            }
-            // 特殊处理param有类型错误的
-            if (value && (node instanceof concepts_1.Param)) {
-                // index在nasl foreach上有脏数据
-                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
-                    const jsonNode = jsonMap.get(node);
-                    jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
-                }
-            }
-            if (value && (node instanceof concepts_1.NewComposite) && (node.typeAnnotation?.typeKind === 'anonymousStructure' || node.typeAnnotation?.typeKind === 'generic')) {
-                const jsonNode = jsonMap.get(node);
-                jsonNode.typeAnnotation = value?.toJSON?.() ?? value;
-            }
-            // jsonSerializer 是 CallLogic，其余是 CallFunction
-            if (node instanceof concepts_1.CallFunction || node instanceof concepts_1.CallLogic) {
-                const tzArgIdx = timeZoneArgumentIndexMap.get(node.calleeName);
-                const args = node.arguments;
-                const tzArg = args ? args[tzArgIdx] : undefined;
-                if (tzArgIdx && tzArg?.keyword === '时区' && !isCoreDateTimeType(node.arguments[0])) {
-                    if (!isFunctionWithFixedTimeZoneParam(node.calleeName)) {
-                        node.arguments.pop();
-                    }
-                }
-                /**
-                * 特殊处理，不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
-                */
-                if (node instanceof concepts_1.CallLogic && node.__TypeArguments?.length) {
-                    const jsonNode = jsonMap.get(node);
-                    jsonNode.typeArguments = node.__TypeArguments.map((type) => type?.toJSON?.() ?? type);
-                    jsonNode.typeAnnotation = node.__TypeAnnotation?.toJSON?.() ?? node.__TypeAnnotation;
-                }
-                // 根据 https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2737356895760128&id1=null&iterationId=null&versionid=null&tab=info
-                // 对CallFunction节点，若其callee为部分List/Map内置函数，则修改其argument类型标注以让服务端据此插入显式的类型转换。规则如下：
-                // - 对argument.expression.typeAnnotation 无需做修改，保持为其实际类型
-                // - 对argument.typeAnnotation，为根据对应Collection的泛型参数的类型填写其类型
-                if (node instanceof concepts_1.CallFunction) {
-                    if (node.calleeNamespace === 'nasl.util') {
-                        const calleeName = node.calleeName;
-                        const listFunctionParamIndexMaps = new Map(Object.entries({
-                            Add: { collection: 0, item: 1 },
-                            Insert: { collection: 0, item: 2 },
-                            Remove: { collection: 0, item: 1 },
-                            Contains: { collection: 0, item: 1 },
-                        }));
-                        const mapFunctionParamIndexMaps = new Map(Object.entries({
-                            MapPut: { collection: 0, key: 1, value: 2 },
-                            MapGet: { collection: 0, key: 1, },
-                            MapRemove: { collection: 0, key: 1 },
-                            MapContains: { collection: 0, key: 1 },
-                        }));
-                        const listParamIndex = listFunctionParamIndexMaps.get(calleeName);
-                        if (listParamIndex) {
-                            const list = node.arguments[listParamIndex.collection];
-                            const item = node.arguments[listParamIndex.item];
-                            const itemExpression = item?.expression;
-                            if (itemExpression) {
-                                const listTypeArgument = list.__TypeAnnotation?.typeArguments?.[0]?.toJSON?.() ?? list.__TypeAnnotation?.typeArguments?.[0];
-                                if (listTypeArgument) {
-                                    const jsonNode = jsonMap.get(item);
-                                    jsonNode.typeAnnotation = listTypeArgument;
-                                }
-                            }
-                        }
-                        else {
-                            const mapParamIndex = mapFunctionParamIndexMaps.get(calleeName);
-                            if (mapParamIndex) {
-                                const map = node.arguments[mapParamIndex.collection];
-                                const key = node.arguments[mapParamIndex.key];
-                                const value = node.arguments[mapParamIndex.value];
-                                const keyExpression = key?.expression;
-                                const valueExpression = value?.expression;
-                                if (keyExpression) {
-                                    const mapKeyTypeArgument = map.__TypeAnnotation?.typeArguments?.[0]?.toJSON?.() ?? map.__TypeAnnotation?.typeArguments?.[0];
-                                    if (mapKeyTypeArgument) {
-                                        const jsonNode = jsonMap.get(key);
-                                        jsonNode.typeAnnotation = mapKeyTypeArgument;
-                                    }
-                                }
-                                if (valueExpression) {
-                                    const mapValueTypeArgument = map.__TypeAnnotation?.typeArguments?.[1]?.toJSON?.() ?? map.__TypeAnnotation?.typeArguments?.[1];
-                                    if (mapValueTypeArgument) {
-                                        const jsonNode = jsonMap.get(value);
-                                        jsonNode.typeAnnotation = mapValueTypeArgument;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // 服务端需要默认值节点有类型来判断父节点是否是日期类型
-            if (node instanceof concepts_1.DefaultValue && !value) {
-                const jsonNode = jsonMap.get(node);
-                const parentNodeType = node.parentNode?.typeAnnotation || node.parentNode?.__TypeAnnotation;
-                if (parentNodeType && jsonNode) {
-                    jsonNode.typeAnnotation = parentNodeType?.toJSON?.() ?? parentNodeType;
-                }
-            }
-            yield;
-        }
-    }
     /**
      * 获取getArgument的参数位的类型
      * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
      * 获取logic的默认值和原来Arg的类型和默认值对应
      */
-    *getArgumentTypeAnnotationWithGenerator(node, QuickInfoNodes, types) {
+    *getArgumentTypeAnnotationWithGenerator(node, types) {
         // 直接复用内部expression的type类型
         if (node.parentNode instanceof concepts_1.CallLogic &&
             node.parentNode.calleeNamespace?.includes('entities') &&
@@ -6093,7 +6081,6 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
             return;
         }
-        this.logger.time('TS 文件变更');
         const fileTsPath = fileNode.getEmbeddedFilePath();
         /**
          * 由于业务组件的声明位置会动态变更
@@ -6106,9 +6093,48 @@ let NaslServer = NaslServer_1 = class NaslServer {
         }
         // 递增ts文件版本号
         this.diagnosticManager.incrementVersionByFilePath(fileTsPath);
-        const result = await utils.timeSlicingWithGenerator(fileNode.toEmbeddedTSFile());
+        // @ts-ignore
+        const fileNodeRaw = this.toRaw(fileNode);
+        // @ts-ignore
+        const targetNodeRaw = this.toRaw(targetNode);
+        if (targetNodeRaw) {
+            if (['BindAttribute', 'BindDirective', 'BindStyle'].includes(targetNodeRaw.concept)) {
+                if (!targetNodeRaw.expression) {
+                    utils.isDebugMode && console.time('remove dirty records');
+                    const usefulRecords = this.diagnosticManager.records.filter(r => this.semData.dirtyViewId === r.id);
+                    usefulRecords.forEach((r, idx) => {
+                        const thisNodePath = targetNodeRaw.nodePath;
+                        r.semanticDiagnostics.forEach((diag, idx) => {
+                            // @ts-ignore
+                            if (this.toRaw(diag.node)?.nodePath.includes(thisNodePath)) {
+                                r.semanticDiagnostics.splice(idx, 1);
+                            }
+                        });
+                    });
+                    utils.isDebugMode && console.timeEnd('remove dirty records');
+                    // 跳过 ts 和错误诊断
+                    return;
+                }
+            }
+        }
+        const viewId = targetNodeRaw.getAncestorRaw('View')?.id;
+        if (viewId) {
+            this.semData.dirtyViewId = viewId;
+        }
+        this.logger.time('TS 文件变更');
+        this.isFirstScreen = true; // getter 会看 naslServer.isFirstScreen
+        this.semData.redirectSlowGetters(fileNodeRaw.getAncestorRaw('App'), this.semData.varScopeCtx);
+        utils.isDebugMode && console.time('Update Semantic Context');
+        await utils.timeSlicingWithGenerator(this.semData.updateSemanticCtxAsPer(fileNodeRaw));
+        utils.isDebugMode && console.timeEnd('Update Semantic Context');
+        utils.isDebugMode && console.time('TS File Update Core Time');
+        const result = await utils.timeSlicingWithGenerator(fileNodeRaw.toEmbeddedTSFile());
+        utils.isDebugMode && console.timeEnd('TS File Update Core Time');
+        this.isFirstScreen = false;
+        this.semData.recoverSlowGetters();
+        fileNodeRaw.concept === 'Logic' && this.semData.updateDirtyIndRetDeps(fileNodeRaw);
         this.logger.timeEnd('TS 文件变更');
-        this.logger.info('TS 文件变更', fileTsPath);
+        utils.isDebugMode && this.logger.info('TS 文件变更', fileTsPath);
         // 当前操作的节点
         // 如果当前没有生成tsFile
         if (!result.sourceMap) {
@@ -6220,6 +6246,10 @@ let NaslServer = NaslServer_1 = class NaslServer {
         })));
         await this.getDiagnosticRecordsAndPushAll();
     }
+    toRaw(nd) {
+        // @ts-ignore
+        return nd.__v_raw ?? nd;
+    }
 };
 exports.NaslServer = NaslServer;
 __decorate([
@@ -6228,6 +6258,9 @@ __decorate([
 __decorate([
     (0, decorators_1.withQueueExecute)('annotation')
 ], NaslServer.prototype, "getNaslAnnotatedJSON", null);
+__decorate([
+    (0, decorators_1.withQueueExecute)('annotation')
+], NaslServer.prototype, "fastGetNaslAnnotatedJSON", null);
 exports.NaslServer = NaslServer = NaslServer_1 = __decorate([
     nasl_sentry_1.sentryMonitorNaslServer
 ], NaslServer);