@lcap/nasl 2.16.1 → 2.17.1

package/src/concepts/EntityProperty__.ts

@@ -22,9 +22,9 @@ import App from './App__';
 import DataSource from './DataSource__';
 
 /**
- * 实体字段
+ * 实体属性
  */
-@concept('实体字段')
+@concept('实体属性')
 export class EntityProperty extends BaseNode {
     /**
      * 产品概念
@@ -33,7 +33,7 @@ export class EntityProperty extends BaseNode {
     concept: 'EntityProperty' = 'EntityProperty';
 
     /**
-     * 实体字段名称
+     * 实体属性名称
      */
     @property()
     name: string = undefined;
@@ -51,13 +51,13 @@ export class EntityProperty extends BaseNode {
     columnName: string = undefined;
 
     /**
-     * 实体字段标题
+     * 实体属性标题
      */
     @property()
     label: string = undefined;
 
     /**
-     * 实体字段描述
+     * 实体属性描述
      */
     @property()
     description: string = undefined;
@@ -81,7 +81,7 @@ export class EntityProperty extends BaseNode {
     defaultValue: string = undefined;
 
     /**
-     * 当前字段是否为主键
+     * 当前属性是否为主键
      */
     @property()
     primaryKey: boolean = undefined;
@@ -189,7 +189,7 @@ export class EntityProperty extends BaseNode {
         return params;
     }
     /**
-     * 设置实体字段名称
+     * 设置实体属性名称
      */
     setName(name: string) {
         const object = {
@@ -214,7 +214,7 @@ export class EntityProperty extends BaseNode {
     }
 
     /**
-     * 设置实体字段标题
+     * 设置实体属性标题
      */
     setLabel(label: string) {
         const object = {
@@ -226,7 +226,7 @@ export class EntityProperty extends BaseNode {
     }
 
     /**
-     * 设置实体字段描述
+     * 设置实体属性描述
      */
     setDescription(description: string) {
         const object = {
@@ -262,7 +262,7 @@ export class EntityProperty extends BaseNode {
     }
 
     /**
-     * 设置当前字段是否为主键
+     * 设置当前属性是否为主键
      */
     setPrimaryKey(primaryKey: boolean) {
         const object = {
@@ -285,6 +285,10 @@ export class EntityProperty extends BaseNode {
         });
     }
 
+
+
+
+
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -360,22 +364,22 @@ export class EntityProperty extends BaseNode {
     getSelectRef() {
         try {
             const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-            let completionChildren: StructureProperty[];
+            let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName) as Structure;
-                    const properties = node?.properties || [];
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = (node as Structure)?.properties || [];
                     completionChildren = properties;
                 } else if (typeNamespace.endsWith('.enums')) {
                     completionChildren = [];
                 } else {
-                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName) as Structure;
-                    const properties = node.properties || [];
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node?.properties || [];
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName) as Structure;
-                const properties = (node?.properties && [...node?.properties]) || [];
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
                 for (let i = 0; i < properties.length; i++) {
                     const item = properties[i];
                     if (item?.typeAnnotation?.typeKind === 'typeParam') {
@@ -531,7 +535,7 @@ export class EntityProperty extends BaseNode {
     }
 
     /**
-     * 设置关联实体字段名称
+     * 设置关联实体属性名称
      */
     setRelationProperty(relationProperty: string) {
         const object = {

package/src/concepts/Entity__.ts

@@ -60,7 +60,7 @@ export class Entity extends BaseNode {
     origin: 'ide' | 'sql' | 'table' | 'excel' = 'ide';
 
     /**
-     * 实体字段列表
+     * 实体属性列表
      */
     @property('EntityProperty')
     properties: Array<EntityProperty> = [];
@@ -135,23 +135,23 @@ export class Entity extends BaseNode {
     }
 
     /**
-    * 插入实体字段
+    * 插入实体属性
     * @internal
-    * @param name 实体字段名称，如果不填会自动生成一个唯一名称
+    * @param name 实体属性名称，如果不填会自动生成一个唯一名称
     */
     _insertPropertyAt(name: string, index: number): EntityProperty;
 
     /**
-    * 插入实体字段
+    * 插入实体属性
     * @internal
-    * @param propertyOptions 实体字段参数
+    * @param propertyOptions 实体属性参数
     */
     _insertPropertyAt(propertyOptions: Partial<EntityProperty>, index: number): EntityProperty;
 
     /**
-    * 插入实体字段
+    * 插入实体属性
     * @internal
-    * @param property 已有的实体字段实例
+    * @param property 已有的实体属性实例
     */
     _insertPropertyAt(property: EntityProperty, index: number): EntityProperty;
 
@@ -184,20 +184,20 @@ export class Entity extends BaseNode {
     }
 
     /**
-     * 插入实体字段
-     * @param name 实体字段名称，如果不填会自动生成一个唯一名称
+     * 插入实体属性
+     * @param name 实体属性名称，如果不填会自动生成一个唯一名称
      */
     insertPropertyAt(name: string, index: number): EntityProperty;
 
     /**
-     * 插入实体字段
-     * @param propertyOptions 实体字段参数
+     * 插入实体属性
+     * @param propertyOptions 实体属性参数
      */
     insertPropertyAt(propertyOptions: Partial<EntityProperty>, index: number): EntityProperty;
 
     /**
-     * 插入实体字段
-     * @param property 已有的实体字段实例
+     * 插入实体属性
+     * @param property 已有的实体属性实例
      */
     insertPropertyAt(property: EntityProperty, index: number): EntityProperty;
 
@@ -212,23 +212,23 @@ export class Entity extends BaseNode {
     }
 
     /**
-     * 添加实体字段
+     * 添加实体属性
      * @internal
-     * @param name 实体字段名称，如果不填会自动生成一个唯一名称
+     * @param name 实体属性名称，如果不填会自动生成一个唯一名称
      */
     _addProperty(name?: string): EntityProperty;
 
     /**
-     * 添加实体字段
+     * 添加实体属性
      * @internal
-     * @param propertyOptions 实体字段参数
+     * @param propertyOptions 实体属性参数
      */
     _addProperty(propertyOptions: Partial<EntityProperty>): EntityProperty;
 
     /**
-     * 添加实体字段
+     * 添加实体属性
      * @internal
-     * @param property 已有的实体字段实例
+     * @param property 已有的实体属性实例
      */
     _addProperty(property: EntityProperty): EntityProperty;
 
@@ -238,21 +238,21 @@ export class Entity extends BaseNode {
     }
 
     /**
-     * 添加实体字段
+     * 添加实体属性
      * @internal
-     * @param name 实体字段名称，如果不填会自动生成一个唯一名称
+     * @param name 实体属性名称，如果不填会自动生成一个唯一名称
      */
     addProperty(name?: string): EntityProperty;
 
     /**
-     * 添加实体字段
-     * @param propertyOptions 实体字段参数
+     * 添加实体属性
+     * @param propertyOptions 实体属性参数
      */
     addProperty(propertyOptions: Partial<EntityProperty>): EntityProperty;
 
     /**
-     * 添加实体字段
-     * @param property 已有的实体字段实例
+     * 添加实体属性
+     * @param property 已有的实体属性实例
      */
     addProperty(property: EntityProperty): EntityProperty;
 
@@ -410,17 +410,17 @@ export class Entity extends BaseNode {
     }
 
 
-    
+
 
     /**
-    * 删除实体字段
-    * @param name 实体字段名称
+    * 删除实体属性
+    * @param name 实体属性名称
     */
     removeProperty(name: string): void;
 
     /**
-     * 删除实体字段
-     * @param property 已有的实体字段实例
+     * 删除实体属性
+     * @param property 已有的实体属性实例
      */
     removeProperty(property: EntityProperty): void;
 
@@ -429,7 +429,7 @@ export class Entity extends BaseNode {
         if (typeof options === 'string') {
             property = this.properties.find((item) => item.name === options);
             if (!property) {
-                throw new Error('找不到实体字段 ' + options);
+                throw new Error('找不到实体属性 ' + options);
             }
         } else {
             property = options;
@@ -746,10 +746,10 @@ export class Entity extends BaseNode {
     }
 
     /**
-     * 获取已有的字段
+     * 获取已有的属性
      * 因为这个primaryIndex不允许添加
      * @param excludedList 排除的集合
-     * @returns 有字段
+     * @returns 有属性
      */
     getRenderEntityIndexExistingNames(excludedList: Array<EntityIndex> = []) {
         const arr = this.getEntityIndexExistingNames(excludedList);

package/src/concepts/EnumItem__.ts

@@ -125,6 +125,14 @@ export class EnumItem extends BaseNode {
     setName(value: string) {
         this.setValue(value);
     }
+    getValue() {
+        return this.value;
+    }
+
+    toJS(state?: TranslatorState): string {
+        return `'${this.value}'`;
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Function__.ts

@@ -1007,7 +1007,7 @@ export class Function extends BaseNode {
             code += `)`;
             if (this.returns.length) {
                 code += ': ';
-                code += this.returns[0].typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                code += this.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true }));
             }
             code += ` => (`;
 
@@ -1065,7 +1065,7 @@ export class Function extends BaseNode {
         });
         code += `) => (`;
         if (this.returns.length) {
-            code += this.returns[0].typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += this.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true }));
         } else {
             code += 'any';
         }

package/src/concepts/InterfaceParam__.ts

@@ -171,6 +171,10 @@ export class InterfaceParam extends BaseNode {
         });
     }
 
+    
+
+    
+
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -291,22 +295,22 @@ export class InterfaceParam extends BaseNode {
     getSelectRef() {
         try {
             const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-            let completionChildren: StructureProperty[];
+            let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName) as Structure;
-                    const properties = node?.properties || [];
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = (node as Structure)?.properties || [];
                     completionChildren = properties;
                 } else if (typeNamespace.endsWith('.enums')) {
                     completionChildren = [];
                 } else {
-                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName) as Structure;
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
                     const properties = node?.properties || [];
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName) as Structure;
-                const properties = (node?.properties && [...node?.properties]) || [];
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
                 for (let i = 0; i < properties.length; i++) {
                     const item = properties[i];
                     if (item?.typeAnnotation?.typeKind === 'typeParam') {

package/src/concepts/LogicItem__.ts

@@ -29,7 +29,7 @@ export class LogicItem extends BaseNode {
      * 产品概念
      */
     @property()
-    concept: 'LogicItem' | 'Start' | 'End' | 'IfStatement' | 'SwitchStatement' | 'SwitchCase' | 'ForEachStatement' | 'WhileStatement' | 'Assignment' | 'Comment' | 'CallLogic' | 'CallFunction' | 'CallInterface' | 'Destination' | 'ValidationRule' | 'Argument' | 'Anchor' | 'JSBlock' | 'Identifier' | 'NullLiteral' | 'BooleanLiteral' | 'StringLiteral' | 'NumericLiteral' | 'BinaryExpression' | 'UnaryExpression' | 'MemberExpression' | 'Unparsed' | 'CallQueryComponent' | 'QueryFromExpression' | 'QueryJoinExpression' | 'QueryFieldExpression' | 'QueryAggregateExpression' | 'QueryOrderByExpression' | 'QueryGroupByExpression' | 'QuerySelectExpression' | 'QueryLimitExpression' | 'SqlQueryComponent' | 'ProcessOutcome' | 'Assignee' = 'LogicItem';
+    concept: 'LogicItem' | 'Start' | 'End' | 'IfStatement' | 'SwitchStatement' | 'SwitchCase' | 'ForEachStatement' | 'WhileStatement' | 'Assignment' | 'BatchAssignment' | 'Comment' | 'CallLogic' | 'CallFunction' | 'CallInterface' | 'Destination' | 'ValidationRule' | 'Argument' | 'Anchor' | 'JSBlock' | 'Construct' | 'Identifier' | 'NullLiteral' | 'BooleanLiteral' | 'StringLiteral' | 'NumericLiteral' | 'BinaryExpression' | 'MatchCase' | 'Match' | 'UnaryExpression' | 'MemberExpression' | 'Unparsed' | 'CallQueryComponent' | 'QueryFromExpression' | 'QueryJoinExpression' | 'QueryFieldExpression' | 'QueryAggregateExpression' | 'QueryOrderByExpression' | 'QueryGroupByExpression' | 'QuerySelectExpression' | 'QueryLimitExpression' | 'SqlQueryComponent' | 'ProcessOutcome' | 'Assignee' = 'LogicItem';
 
     /**
      * 逻辑项标题
@@ -220,7 +220,7 @@ export class LogicItem extends BaseNode {
     }
 
     toBrief(): string {
-        return '-'
+        return '-';
     }
 
     /**

package/src/concepts/Logic__.ts

@@ -2,7 +2,10 @@ import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState
 import Namespace from './Namespace__';
 import CallQueryComponent from './CallQueryComponent__';
 import ForEachStatement from './ForEachStatement__';
+import Assignment from './Assignment__';
+import Identifier from './Identifier__';
 import BindEvent from './BindEvent__';
+import BatchAssignment from './BatchAssignment__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -786,7 +789,7 @@ export class Logic extends BaseNode {
 
 
 
-    
+
 
     /**
     * 插入逻辑项
@@ -820,7 +823,7 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
-    
+
 
     /**
      * 插入逻辑项
@@ -844,7 +847,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
-    
+
 
     /**
      * 添加逻辑项
@@ -865,7 +868,7 @@ export class Logic extends BaseNode {
         return this._insertItemInBodyAt(options as any, index);
     }
 
-    
+
 
     /**
      * 添加逻辑项
@@ -890,7 +893,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
-    
+
 
     /**
     * 插入逻辑项
@@ -924,7 +927,7 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
-    
+
 
     /**
      * 插入逻辑项
@@ -948,7 +951,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
-    
+
 
     /**
      * 添加逻辑项
@@ -969,7 +972,7 @@ export class Logic extends BaseNode {
         return this._insertItemInPlaygroundAt(options as any, index);
     }
 
-    
+
 
     /**
      * 添加逻辑项
@@ -995,7 +998,7 @@ export class Logic extends BaseNode {
     }
 
 
-    
+
 
     /**
     * 删除事务
@@ -1258,7 +1261,7 @@ export class Logic extends BaseNode {
         return logicItem.delete();
     }
 
-    
+
 
     /**
      * 删除逻辑项
@@ -1620,9 +1623,29 @@ export class Logic extends BaseNode {
             // 没有参数的
             code += '()';
         }
-        if (this.returns.length) {
+
+        // 需要类型推导的局部变量/返回值需要调整申明顺序
+        const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+        this.traverseChildren((el) => {
+            if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
+                const tsCode = el.toEmbeddedTS();
+                const advanceVar = this.variables?.find((variable) =>
+                    !variable.typeAnnotation && tsCode.includes(`${variable.name} = `));
+                if (advanceVar && !advanceMap.get(advanceVar)) {
+                    advanceMap.set(advanceVar, el);
+                }
+                const advanceRn = this.returns?.find((ret) =>
+                    !ret.typeAnnotation && tsCode.includes(`${ret.name} = `));
+                if (advanceRn && !advanceMap.get(advanceRn)) {
+                    advanceMap.set(advanceRn, el);
+                }
+            }
+        });
+
+        // 兼容 return 没有类型情况
+        if (this.returns.length && this.returns[0].typeAnnotation) {
             code += ': ';
-            code += this.returns[0].typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += this.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true }));
         }
         if (prefix === 'arrowFunction') {
             code += ` => `;
@@ -1643,15 +1666,43 @@ export class Logic extends BaseNode {
             code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
             code += '\n';
         });
+
         this.variables.forEach((variable) => {
-            code += indent((state?.tabSize || 0) + 1) + 'let ';
-            code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            if (!advanceMap.get(variable)) {
+                code += indent((state?.tabSize || 0) + 1) + 'let ';
+                code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            }
         });
 
         this.returns.forEach((ret) => {
+            if (!advanceMap.get(ret)) {
+                code += indent((state?.tabSize || 0) + 1) + 'let ';
+                code += ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            }
+        });
+
+        advanceMap.forEach((assignment, node) => {
             code += indent((state?.tabSize || 0) + 1) + 'let ';
-            code += ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ' = ';
+            if (assignment instanceof BatchAssignment) {
+                assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+                    const leftCode = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                    if (leftCode === node.name) {
+                        const rightCode = rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.rights[rightIndex[0]]?.members[rightIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                        code += this.getRightCode(rightCode, assignment);
+                    }
+                });
+            } else {
+                // 因为右侧枚举要赋值就得new 一下；
+                if (assignment.right && assignment.right instanceof Identifier && assignment.right.namespace && assignment.right.namespace.endsWith('enums')) {
+                    code += 'new ';
+                }
+                const rightCode = (assignment.right && assignment.right.toEmbeddedTS) ? assignment.right.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
+                code += this.getRightCode(rightCode, assignment);
+            }
             code += ';\n';
         });
 
@@ -1683,6 +1734,36 @@ export class Logic extends BaseNode {
         return code;
     }
 
+    getRightCode(code: string, assignment: Assignment | BatchAssignment): string {
+        if (assignment instanceof Assignment && !assignment.right)
+            return code;
+
+        // ForEachStatement 内部变量需要替换处理，如 item、index
+        const forEachStatement = assignment.getAncestor('ForEachStatement') as ForEachStatement;
+        if (forEachStatement) {
+            const { item, index, each } = forEachStatement;
+            return code.replace(/\S+/g, ($1) => {
+                if ($1.includes('(') || $1.includes('['))
+                    return $1;
+                if ($1.includes(`${item.name},`)
+                    || $1.includes(`${item.name}.`)
+                    || $1.includes(`${item.name};`)
+                    || $1.includes(`${item.name})`)
+                    || $1 === item.name) {
+                    const eachTSCode = each.toEmbeddedTS();
+                    return $1.replaceAll(item.name, eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`);
+                }
+                if ($1.includes(`${index.name},`)
+                    || $1.includes(`${index.name};`)
+                    || $1.includes(`${index.name})`)
+                    || $1 === index.name)
+                    return $1.replaceAll(index.name, 'new nasl.core.Integer(0)');
+                return $1;
+            });
+        } else
+            return code;
+    }
+
     getNamespace(): string {
         if (this.parentNode) {
             const parentNamespace = (this.parentNode as any)?.getNamespace();
@@ -1774,7 +1855,7 @@ export class Logic extends BaseNode {
             }
         }, { node: root }, {
             mode: 'anyObject',
-            excludedKeySet: new Set(['parentNode']),
+            excludedKeySet: new Set(['parentNode', '__assignment__']),
         });
         for (const node of set) {
             (<CallQueryComponent>node).saveStructure();