@lcap/nasl 2.21.0-beta.2 → 2.21.0-beta.3

package/src/sentry/index.ts

@@ -0,0 +1,134 @@
+export const CONSTRUCTOR_HOOK = 'constructor';
+export const BEFORE_HOOK = 'before';
+export const AFTER_HOOK = 'after';
+
+export const NASL_NODE = 'nasl-node';
+export const TS_WORKER_MESSAGER = 'ts-worker-messager';
+
+type ClassType = { new(...args: any[]): any };
+
+type Source = {
+    instance: any;
+    hook: string;
+    name: string;
+    params: any[];
+    result?: any;
+};
+
+type Listener = (source: Source) => void;
+
+type Monitor = (key: string) => <T extends ClassType>(SourceClass: T) => T;
+
+const previousStore: { [key:string]: Source } = {};
+const listenersStore: { [key:string]: Listener[] } = {};
+
+const isPromise = (obj: any) => obj && typeof obj.then === 'function';
+
+export const getPrevious = (key: string) => previousStore[key];
+
+export const removeListener = (key: string) => (listener: Listener) => {
+    listenersStore[key] = listenersStore[key] || [];
+    listenersStore[key] = listenersStore[key].filter((item) => item !== listener);
+};
+
+export const addListener = (key: string) => (listener: Listener, capture = false) => {
+    listenersStore[key] = listenersStore[key] || [];
+
+    if (capture) {
+        listenersStore[key] = [listener, ...listenersStore[key]];
+    } else {
+        listenersStore[key] = listenersStore[key].concat(listener);
+    }
+
+    return () => removeListener(key)(listener);
+};
+
+const fireListeners = (key: string) => (source: Source) => {
+    listenersStore[key] = listenersStore[key] || [];
+    listenersStore[key].forEach((listener) => listener(source));
+
+    return source;
+};
+
+export const sentryMonitor: Monitor = (key) => (SourceClass) => {
+    if (!key) {
+        return SourceClass;
+    }
+
+    class TargetClass extends SourceClass {
+        constructor(...params: any[]) {
+            super(...params); // tslint-disable
+
+            fireListeners(key)({
+                hook: CONSTRUCTOR_HOOK,
+                name: 'constructor',
+                instance: this,
+                result: this,
+                params,
+            });
+        }
+    }
+
+    const properties = Object.getOwnPropertyNames(SourceClass.prototype);
+    const names = properties.filter((property) => {
+        if (property === 'constructor') {
+            return false;
+        }
+
+        return typeof SourceClass.prototype[property] === 'function';
+    });
+
+    names.forEach((name) => {
+        const { [name]: callback } = SourceClass.prototype;
+
+        TargetClass.prototype[name] = function (...params: any[]) {
+            const current = previousStore[key];
+
+            previousStore[key] = fireListeners(key)({
+                hook: BEFORE_HOOK,
+                instance: this,
+                name,
+                params,
+            });
+
+            const result = callback.apply(this, params);
+
+            if (isPromise(result)) {
+                return result.then((data: any) => {
+                    fireListeners(key)({
+                        hook: AFTER_HOOK,
+                        instance: this,
+                        result: data,
+                        params,
+                        name,
+                    });
+
+                    previousStore[key] = current;
+                    return data;
+                });
+            }
+
+            fireListeners(key)({
+                hook: AFTER_HOOK,
+                instance: this,
+                name,
+                params,
+                result,
+            });
+
+            previousStore[key] = current;
+            return result;
+        };
+    });
+
+    return TargetClass;
+};
+
+export const getPreviousFromNaslNode = () => getPrevious(NASL_NODE);
+export const getPreviousFromTSWorkerMessager = () => getPrevious(TS_WORKER_MESSAGER);
+
+export const addListenerToNaslNode = addListener(NASL_NODE);
+export const addListenerToTSWorkerMessager = addListener(TS_WORKER_MESSAGER);
+
+export const sentryMonitorNaslNode = sentryMonitor(NASL_NODE);
+export const sentryMonitorTSWorkerMessager = sentryMonitor(TS_WORKER_MESSAGER);

package/src/server/entity2LogicNamespace.ts

@@ -212,7 +212,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 returns: [
                     new Return({
                         name: 'result',
-                        typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                        typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                     }),
                 ],
                 body: [],

package/src/server/extendBaseNode.ts

@@ -1,8 +1,9 @@
 import { FileNode, NaslServer } from './naslServer';
 import * as tsProtocol from 'typescript/lib/protocol';
 import { MinRange } from './translator';
-import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Process, Role, Structure, View, ViewElement, Frontend } from '../concepts';
+import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Process, Role, Structure, View, ViewElement, Frontend, TypeAnnotation, StructureProperty, App } from '../concepts';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 interface SetNameNode extends BaseNode {
     setName(name: string): any;
@@ -399,3 +400,62 @@ BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnot
         console.log(err);
     }
 };
+
+function newNode(node: BaseNode, parentNode: TypeAnnotation, needNewStructure: boolean) {
+    if (needNewStructure && node?.toJSON) {
+        return (BaseNode.from(node.toJSON(), parentNode, '') as Structure);
+    }
+    return (node as Structure);
+}
+/**
+ * 获取下一级变量
+ */
+
+BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation: TypeAnnotation, needNewStructure = false) {
+    try {
+        const typeAnnotation = newTypeAnnotation || (this as any).typeAnnotation || this.__TypeAnnotation;
+        const { typeName, typeKind, typeNamespace, typeArguments } = typeAnnotation;
+        let completionChildren: any;
+        if (typeKind === 'reference') {
+            if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth') {
+                const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), typeAnnotation, needNewStructure);
+                const properties = (node as Structure)?.properties || [];
+                completionChildren = properties;
+            } else if (typeNamespace.endsWith('.enums')) {
+                completionChildren = [];
+            } else {
+                let app: App;
+                if (this.concept === 'App') {
+                    app = (this as App);
+                } else {
+                    app = this.rootNode || typeAnnotation.app;
+                }
+                const node = newNode(getNodeByNodeCallee(app, typeNamespace + '.' + typeName), typeAnnotation, needNewStructure);
+                const properties = node?.properties || [];
+                completionChildren = properties;
+            }
+        } else if (typeKind === 'generic') {
+            const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), typeAnnotation, needNewStructure);
+            const properties = (node?.properties && [...node?.properties]) || [];
+            for (let i = 0; i < properties.length; i++) {
+                const item = properties[i];
+                if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                    const newItem = StructureProperty.from(item.toJSON());
+                    newItem.typeAnnotation = typeArguments[0];
+                    newItem.parentNode = this;
+                    properties[i] = newItem;
+                }
+            }
+            completionChildren = properties;
+        } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+            const node = newNode(getNaslNodeByNodeCallee(typeNamespace, typeName), typeAnnotation, needNewStructure);
+            const properties = (node?.properties && [...node?.properties]) || [];
+            completionChildren = properties;
+        } else {
+            completionChildren;
+        }
+        return completionChildren;
+    } catch (err) {
+        console.log(err);
+    }
+}

package/src/server/formatTsUtils.ts

@@ -24,7 +24,7 @@ interface variableItem {
  */
 function formatTs2TypeString(displayParts: Array<{ text: string; kind: string }>) {
     let str = '';
-    displayParts.forEach((item) => {
+    displayParts?.forEach((item) => {
         str += item.text;
     });
     return str;
@@ -122,7 +122,7 @@ export function displayString2TypeAnnotation(typeStr: string, parentPrefix?: str
     if (type === 'Promise<void>')
         return null;
     // 把后面结尾里带()的比如
-    // 'function nasl.core.add(left: nasl.core.Long, right: nasl.core.Long): nasl.core.Long (+12 overloads)'
+    // 'function nasl.core.add(left: nasl.core.Integer, right: nasl.core.Integer): nasl.core.Integer (+12 overloads)'
     if (type.includes('(') && type.includes(')')) {
         type = type.replace(/\([^\)]*\)/g, '');
     }
@@ -389,7 +389,7 @@ function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
         entity1: app.dataSources.defaultDS.entities.Entity1;
         lCAPRolePerMapping: app.dataSources.defaultDS.entities.LCAPRolePerMapping;
     }>;
-    total: nasl.core.Long;
+    total: nasl.core.Integer;
 }`
  */
 function getAStructureObjectStringType(type: string, parent: any, node: BaseNode) {
@@ -481,7 +481,7 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
             // 当前的类型如 app.entitys.entity1 nasl.core.String
             let typeKey: string;
             if (item.completionDetail) {
-                if (item.completionDetail.nodeType) {
+                if (item.completionDetail?.hasOwnProperty('nodeType')) {
                     const typeAnnotation = type2TypeAnnotation(item.completionDetail.nodeType);
                     typeKey = typeAnnotation?.typeKey;
                 } else {
@@ -505,7 +505,7 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                     }
                     typeKey = getPlatformType(currentType);
                 }
-            } else if (item instanceof StructureProperty) {
+            } else if (item instanceof StructureProperty || item instanceof EntityProperty) {
                 typeKey = item?.typeAnnotation?.typeKey;
             }
             // 如果没有父节点就是Identifier

package/src/server/getLogics.ts

@@ -206,13 +206,6 @@ export async function getLogics(node: CallLogic | BindEvent| Identifier | Logic,
                         logics: stdlibNamespace.findChild('configuration').logics,
                         expanded: false,
                     }),
-                    new Namespace({
-                        name: 'category',
-                        path: `io`,
-                        title: '文件处理',
-                        logics: stdlibNamespace.findChild('io').logics,
-                        expanded: false,
-                    }),
                 ],
                 expanded: false,
             });
@@ -224,6 +217,14 @@ export async function getLogics(node: CallLogic | BindEvent| Identifier | Logic,
                     logics: stdlibNamespace.findChild('browser').logics.filter((item) => ['navigateToUserInfo', 'getWeChatHeadImg', 'getWeChatNickName', 'getWeChatOpenid'].includes(item.name)),
                     expanded: false,
                 }));
+            } else if (node?.frontend?.type === 'pc') {
+                systemTree.children.push(new Namespace({
+                    name: 'category',
+                    path: `io`,
+                    title: '文件处理',
+                    logics: stdlibNamespace.findChild('io').logics,
+                    expanded: false,
+                }));
             }
 
             app.dependencies.forEach((item) => {

package/src/server/naslServer.ts

@@ -5,7 +5,8 @@ import { Worker } from 'worker_threads';
 /// #endif
 
 import { config } from '../config';
-import Messager from '../common/Messager';
+import { sentryMonitorTSWorkerMessager } from '../sentry';
+import OriginalMessager from '../common/Messager';
 import * as tsProtocol from 'typescript/lib/protocol';
 import { formatEnums } from '../server/getMemberIdentifier';
 
@@ -96,6 +97,8 @@ const EmbeddedTSFileOffsetMap: { [name: string]: number } = {
     ConfigProperty: 12,
 };
 
+const Messager = sentryMonitorTSWorkerMessager(OriginalMessager);
+
 export interface FileNode extends BaseNode {
     getEmbeddedFilePath(name?: string): string;
     toEmbeddedTSFile(): {
@@ -157,7 +160,7 @@ export function getDisplayString2Type(displayString: string) {
 }
 
 export class NaslServer {
-    messager: Messager = undefined;
+    messager: OriginalMessager = undefined;
 
     worker: Worker = undefined;
 
@@ -900,25 +903,6 @@ export class NaslServer {
                 });
             }
             record.semanticDiagnostics = record.semanticDiagnostics
-                /**
-                 * reduce 为去除重复的 'Duplicate identifier xxxx' 报错
-                 * 原属于 TS@4.x 的 bug，在 TS@5.0-dev 后修复，详见：https://github.com/microsoft/TypeScript/issues/51437
-                 * 触发场景：
-                 *   OQL查询中写入SQL语句：'select * from Entity1 ee, Entity1 ee, Entity1 ee, Entity1 ee'
-                 *   翻译出的TS代码中，ee 被成功检查为重复变量，但 ee 报错的数量超过 ee 实际的出现数量，需对同一 token 的报错进行去重
-                 */
-                .reduce((res, item: any) => {
-                    const hit = item.text.startsWith('Duplicate identifier') && res.some((r: any) => (r.text === item.text
-                        && r.start.line === item.start.line
-                        && r.start.offset === item.start.offset
-                        && r.end.line === item.end.line
-                        && r.end.offset === item.end.offset));
-
-                    if (!hit) {
-                        res.push(item);
-                    }
-                    return res;
-                }, [])
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
             record.semanticDiagnostics.push(...this._attachDiagnostics(node));
@@ -931,7 +915,7 @@ export class NaslServer {
                         let currentNode = diagnostic.node;
 
                         // 数据源警告类型降级
-                        if (currentNode.concept === 'DataSource') {
+                        if (currentNode.concept === 'DataSource' && diagnostic.originalDiagnostic?.text === 'DataSource connection error') {
                             diagnostic.severity = 'warning';
                             record.suggestionDiagnostics.push(diagnostic);
                             return null;
@@ -1388,23 +1372,36 @@ export class NaslServer {
                             if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
                                 const bindExpression = bindAttr.expression;
                                 let diagnostic;
-                                if (bindExpression.concept !== 'Identifier' && bindExpression.concept !== 'MemberExpression') {
-                                    diagnostic = {
-                                        node: bindAttr,
-                                        severity: 'error',
-                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
-                                    };
-                                } else {
+                                if (bindExpression.concept === 'MemberExpression') {
+                                    let current = (bindExpression as MemberExpression);
                                     if ((bindExpression as MemberExpression).isEnum()) {
                                         diagnostic = {
-                                            node: bindAttr,
+                                            node: bindExpression,
                                             severity: 'error',
                                             message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
                                         };
+                                    } else {
+                                        while (current.object) {
+                                            if (current.object.concept !== 'MemberExpression' && current.object.concept !== 'Identifier') {
+                                                diagnostic = {
+                                                    node: bindExpression,
+                                                    severity: 'error',
+                                                    message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                                };
+                                                break;
+                                            }
+                                            current = (current.object as MemberExpression);
+                                        }
                                     }
+                                } else if (bindExpression.concept !== 'Identifier') {
+                                    diagnostic = {
+                                        node: bindExpression,
+                                        severity: 'error',
+                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                    };
                                 }
                                 if (diagnostic) {
-                                    bindAttr.tsErrorDetail = diagnostic;
+                                    bindExpression.tsErrorDetail = diagnostic;
                                     diagnostics.push(diagnostic);
                                 }
                             }
@@ -1684,22 +1681,29 @@ export class NaslServer {
                         }
                     });
                 }
+                Object.keys(typeMap).forEach((item) => {
+                    if (typeMap[item].length > 1) {
+                        typeMap[item].forEach((nodeItem: any) => {
+                            const diagnostic = {
+                                node: nodeItem,
+                                severity: 'error',
+                                message: '匹配：重复添加类型',
+                                titleTip: '重复添加此项',
+                            };
+                            nodeItem.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        });
+                    }
+                });
+            } else if (node.expression) {
+                const diagnostic = {
+                    node: node.expression,
+                    severity: 'error',
+                    message: '类型不匹配，传入类型：void',
+                };
+                node.expression.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
-
-            Object.keys(typeMap).forEach((item) => {
-                if (typeMap[item].length > 1) {
-                    typeMap[item].forEach((nodeItem: any) => {
-                        const diagnostic = {
-                            node: nodeItem,
-                            severity: 'error',
-                            message: '匹配：重复添加类型',
-                            titleTip: '重复添加此项',
-                        };
-                        nodeItem.tsErrorDetail = diagnostic;
-                        diagnostics.push(diagnostic);
-                    });
-                }
-            });
         }
         if (node instanceof MatchCase && (node.getAncestor('Match') as Match)?.isExpression && node.body.length === 0) {
             // 如果不是其他就标红
@@ -1831,8 +1835,10 @@ export class NaslServer {
                 if (!(node.right.tsErrorDetail) && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
                     const excludeList = [
                         'nasl.collection.List<nasl.core.String>',
+                        'nasl.collection.List<nasl.core.Text>',
                         'nasl.collection.List<nasl.core.Email>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.String>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.Text>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
                     ];
                     const excludeList2 = [
@@ -2173,6 +2179,31 @@ export class NaslServer {
                 });
             }
         }
+        if ((node instanceof Param || node instanceof Return) && node.parentNode instanceof Process) {
+            const { currentSource } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    pos = code.indexOf(node.name, pos + prefix.length);
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: (fileNode as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
         if (node instanceof ProcessElement) {
             if (currentSource) {
                 const code = currentSource.code;
@@ -2196,6 +2227,34 @@ export class NaslServer {
                 });
             }
         }
+        if (node instanceof Return && node.parentNode instanceof ProcessElement) {
+            const { currentSource } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                // 需要再次定位到processelement对象上，避免process上存在同名参数
+                pos = code.indexOf(node.parentNode.name, pos + prefix.length);
+                while (pos !== -1) {
+                    pos = code.indexOf(node.name, pos + prefix.length);
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                    // 需要再次定位到processelement对象上，避免process上存在同名参数
+                    pos = code.indexOf(node.parentNode.name, pos + node.parentNode.name.length);
+                }
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: (fileNode as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
         // console.log(refsList, 'refsList');
         return refsList;
     }
@@ -3007,7 +3066,7 @@ export class NaslServer {
         if (node instanceof Param) {
             // index在nasl foreach上有脏数据
             if (node.parentKey === 'index' && node.parentNode instanceof ForEachStatement) {
-                return TypeAnnotation.createPrimitive('Long');
+                return TypeAnnotation.createPrimitive('Integer');
             }
         }
 
@@ -3070,6 +3129,11 @@ export class NaslServer {
                 types.set(node, (node as Variable).typeAnnotation);
                 return;
             }
+            // 如果 入参不是虚拟节点的，就不去请求类型
+            // 只有虚拟节点的入参，才没有类型
+            if (node.concept === 'Param' && node.parentKey !== 'virtualParams') {
+                return;
+            }
             if (![
                 'Identifier',
                 'UnaryExpression',
@@ -3087,8 +3151,10 @@ export class NaslServer {
                 'OqlQueryComponent',
                 'QueryFieldExpression',
                 'QueryGroupByExpression',
+                'Param',
             ].includes(node.concept))
                 return;
+
             // 要去ls那边获取的
             newQuickInfoNodes.push(itemDetail);
             const fileDetail = {
@@ -3096,6 +3162,7 @@ export class NaslServer {
                 line: lsp2tspNumber(item.range.start.line),
                 offset: lsp2tspNumber(item.range.start.character),
             };
+            // 位置计算偏移
             if (node.concept === 'BinaryExpression'
                 || node.concept === 'CallLogic'
                 || node.concept === 'CallFunction'
@@ -3164,8 +3231,8 @@ export class NaslServer {
             // console.log('原始：', displayString);
             // console.log('方案2：', item?.[0]?.nodeType);
             const nodeTypeAnnotation = type2TypeAnnotation(item?.[0]?.nodeType);
-            console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
-            types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
+            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
+            types.set(newQuickInfoNodes[index].node, (Object.freeze(nodeTypeAnnotation) as TypeAnnotation));
             (newQuickInfoNodes[index].node as any).__nodeType = Object.freeze(item?.[0]?.nodeType);
 
             // console.log('方案1：', displayString1);
@@ -3211,9 +3278,9 @@ export class NaslServer {
                         }
                     }
                     if (value instanceof TypeAnnotation) {
-                        node.__TypeAnnotation = (Object.freeze(value) as TypeAnnotation);
+                        node.__TypeAnnotation = value;
                     } else if (value.typeAnnotation) {
-                        node.__TypeAnnotation = (Object.freeze(value.typeAnnotation) as TypeAnnotation);
+                        node.__TypeAnnotation = value.typeAnnotation;
                     }
                 } else {
                     // 清空原来已经赋值上去的类型，可能原来有现在没有了
@@ -3388,7 +3455,7 @@ export class NaslServer {
                             concept: 'TypeAnnotation',
                             typeKind: 'primitive',
                             typeNamespace: 'nasl.core',
-                            typeName: 'Long',
+                            typeName: 'Integer',
                             typeArguments: null,
                             inferred: null,
                         },
@@ -3402,7 +3469,7 @@ export class NaslServer {
                 // index在nasl foreach上有脏数据
                 if (node.parentKey === 'index' && node.parentNode instanceof ForEachStatement) {
                     const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
-                    jsonNode.typeAnnotation = TypeAnnotation.createPrimitive('Long').toJSON();
+                    jsonNode.typeAnnotation = TypeAnnotation.createPrimitive('Integer').toJSON();
                 }
             }
             if (node instanceof Match) {

package/src/server/translator.ts

@@ -68,7 +68,7 @@ function transformType(tsType: string): string {
     else if (tsType === 'Double')
         return '小数';
     else if (tsType === 'Decimal')
-        return '小数';
+        return '精确小数';
     else if (tsType === 'Long')
         return '长整数';
     else if (tsType === 'DateTime')
@@ -550,7 +550,8 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             }
         } 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'的其中一种`;
+                const cap = /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text);
+                tsErrorDetail.message = tsErrorDetail.message = `参数类型不一致！传入类型：${transformType(cap[1])}，接收类型：字符串 或 整数 或 布尔值 或 长整数 或 精确小数`;
             } else if (text.includes(`parameter of type 'never'`)) {
                 tsErrorDetail.message = '自动推导不出类型！newMap中有未知类型';
             }

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/storage/init.ts

@@ -414,12 +414,10 @@ class TaskQueue {
         }));
         await storageService.saveFrontendNasl({
             body: {
-                frontendDataDTO: {
-                    nasl: app.toJSON(),
-                    failedQueue,
-                    queue,
-                    errorInfo: options.errorInfo,
-                },
+                nasl: app.toJSON(),
+                failedQueue,
+                queue,
+                errorInfo: options.errorInfo,
             },
         }).catch((err: any) => {
             console.log('备份 nasl 失败：', err);
@@ -553,7 +551,7 @@ export function handleApp(app: any) {
             app._action = '';
             app._noTimer = undefined;
             if (Array.isArray(collectingList) && collectingList.length) {
-                app.naslServer?.embeddedTSEmitter?.emit('change', {
+                app.naslServer.embeddedTSEmitter.emit('change', {
                     value: collectingList,
                 });
                 await doAction(app, {
@@ -574,7 +572,7 @@ export function handleApp(app: any) {
     app.on('storage', (event: any) => {
         // 是否正在收集
         if (app._isCollectingCount === 0) {
-            app.naslServer?.embeddedTSEmitter?.emit('change', {
+            app.naslServer.embeddedTSEmitter.emit('change', {
                 value: [event],
             });
             let actionMsg = '';