@lcap/nasl 2.16.1 → 2.17.1

package/src/concepts/SelectMembers__.ts

@@ -0,0 +1,378 @@
+import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import BatchAssignment from './BatchAssignment__';
+import AssignmentLine from './AssignmentLine__';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import LogicItem from './LogicItem__';
+
+/**
+ * 调用逻辑
+ */
+@concept('调用逻辑')
+export class SelectMembers extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'SelectMembers' = 'SelectMembers';
+
+    /**
+     * hideMembers
+     */
+    @property()
+    hideMembers: boolean = false;
+
+    /**
+     * 根表达式
+     */
+    @property('LogicItem')
+    expression: LogicItem = undefined;
+
+    /**
+     * 成员表达式
+     */
+    @property('LogicItem')
+    members: Array<LogicItem> = [];
+
+    
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<SelectMembers>) {
+        source = Object.assign({}, SelectMembers.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): SelectMembers {
+        return super.from(source, parentNode, parentKey) as SelectMembers;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeSelectMembers?.(this);
+        }
+        return params;
+    }
+    /**
+     * 设置hideMembers
+     */
+    setHideMembers(hideMembers: boolean) {
+        const object = {
+            hideMembers,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置根表达式
+     */
+    setExpression(expression: LogicItem) {
+        expression._delete();
+        const relationOptions = { parentNode: this, parentKey: 'expression' };
+        Object.assign(expression, relationOptions);
+        const object = {
+            expression,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置成员表达式
+     */
+    setMembers(members: Array<LogicItem>) {
+        const object = {
+            members,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+        getLogicItemExistingNames(excludedList: Array<LogicItem> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.members || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getLogicItemUniqueName(name = 'logicItem1') {
+        return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
+    }
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+    */
+    _insertLogicItemAt(name: string, index: number): LogicItem;
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertLogicItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItem 已有的逻辑项实例
+    */
+    _insertLogicItemAt(logicItem: LogicItem, index: number): LogicItem;
+
+    _insertLogicItemAt(options: string | Partial<LogicItem> | LogicItem, index: number) {
+        const logicItemOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'members' };
+        let logicItem: LogicItem;
+        if (!options) {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                name: this.getLogicItemUniqueName(),
+            }, this, 'members');
+        } else if (typeof options === 'string') {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                name: options,
+            }, this, 'members');
+        } else if (options instanceof LogicItem) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            logicItem = options;
+            Object.assign(logicItem, relationOptions);
+        } else {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                ...options,
+            }, this, 'members');
+        }
+        this.members.splice(index, 0, logicItem);
+        return logicItem;
+    }
+
+    /**
+     * 插入逻辑项
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    insertLogicItemAt(name: string, index: number): LogicItem;
+
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertLogicItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertLogicItemAt(logicItem: LogicItem, index: number): LogicItem;
+
+    insertLogicItemAt(options: string | Partial<LogicItem> | LogicItem, index: number) {
+        const node = this._insertLogicItemAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'members',
+        });
+        return node;
+    }
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    _addLogicItem(name?: string): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addLogicItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addLogicItem(logicItem: LogicItem): LogicItem;
+
+    _addLogicItem(options?: string | Partial<LogicItem> | LogicItem) {
+        const index = this.members.length;
+        return this._insertLogicItemAt(options as any, index);
+    }
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    addLogicItem(name?: string): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addLogicItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addLogicItem(logicItem: LogicItem): LogicItem;
+
+    addLogicItem(options?: string | Partial<LogicItem> | LogicItem) {
+        const node = this._addLogicItem(options as any);
+        const index = this.members.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'members',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除逻辑项
+    * @param name 逻辑项名称
+    */
+    removeExpression(name: string): void;
+
+    /**
+     * 删除逻辑项
+     * @param expression 已有的逻辑项实例
+     */
+    removeExpression(expression: LogicItem): void;
+
+    removeExpression(options: string | LogicItem) {
+        let expression: LogicItem;
+        if (typeof options === 'string') {
+            expression = this.expression;
+            if (!expression) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        } else {
+            expression = options;
+        }
+        return expression.delete();
+    }
+
+    
+
+    /**
+    * 删除逻辑项
+    * @param name 逻辑项名称
+    */
+    removeLogicItemInMembers(name: string): void;
+
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeLogicItemInMembers(logicItem: LogicItem): void;
+
+    removeLogicItemInMembers(options: string | LogicItem) {
+        let logicItem: LogicItem;
+        if (typeof options === 'string') {
+            logicItem = this.members.find((item) => item.name === options);
+            if (!logicItem) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        } else {
+            logicItem = options;
+        }
+        return logicItem.delete();
+    }
+
+    __removeLogicItem(logicItem: LogicItem) {
+        const parentKey = logicItem.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logicItem);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logicItem) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    get lines() {
+        const batchAssignment: any = this.getAncestor('BatchAssignment');
+        const parentKey = this.parentKey;
+        const firstIndex = parentKey === 'left' ? 0 : batchAssignment.rights.findIndex((selectMember: SelectMembers) => selectMember === this);
+        let count = 0;
+        batchAssignment.assignmentLines.forEach((line: AssignmentLine) => {
+            const lineIndex = parentKey === 'left' ? line.leftIndex[0] : line.rightIndex[0];
+            if (lineIndex === firstIndex)
+                count++;
+        });
+        return count;
+    }
+
+    get error() {
+        let error = false;
+        const batch: any = this.parentNode;
+        if (this.parentKey === 'rights') {
+            const firstIndex = batch.rights.findIndex((right: SelectMembers) => right === this);
+            batch.assignmentLines.forEach(({ leftIndex, rightIndex }: any) => {
+                if (rightIndex[0] === firstIndex && batch.left?.members[leftIndex[1]].tsErrorDetail) {
+                    error = true;
+                }
+            });
+            return error;
+        }
+        return !!this.members.find((member) => member.tsErrorDetail);
+    }
+
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        const code = '';
+        return code;
+    }
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap.SelectMembers = SelectMembers;
+export default SelectMembers;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/SqlQueryComponent__.ts

@@ -1,7 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
-import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
+import Structure from './Structure__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -58,6 +58,8 @@ export class SqlQueryComponent extends LogicItem {
     @property()
     ideVersion: string = undefined;
 
+    
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -71,6 +73,7 @@ export class SqlQueryComponent extends LogicItem {
         return super.from(source, parentNode, parentKey) as SqlQueryComponent;
     }
 
+    
     /**
      * 设置SQL 查询
      */
@@ -83,6 +86,10 @@ export class SqlQueryComponent extends LogicItem {
         });
     }
 
+    
+
+    
+
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -286,24 +293,24 @@ export class SqlQueryComponent extends LogicItem {
     getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
             const { typeName, typeKind, typeNamespace } = newTypeAnnotation || 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') {
                 // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
                 // }
-                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/StringLiteral__.ts

@@ -85,6 +85,13 @@ export class StringLiteral extends LogicItem {
     toJS(): string {
         let code = ``;
         if (typeof this.value === 'string') {
+            //const scope = this.view ? 'this' : 'Vue.prototype';
+            //code += `${scope}.$genInitFromSchema(${JSON.stringify({
+            //    concept: 'TypeAnnotation',
+            //    typeKind: 'primitive',
+            //    typeNamespace: 'nasl.core',
+            //    typeName: 'String',
+            //})}, '${this.value.replace(/['"`\\]/g, (m) => `\\${m}`)}')`;
             code += `'${this.value.replace(/['"`\\]/g, (m) => `\\${m}`)}'`;
         }
         return code;
@@ -97,7 +104,7 @@ export class StringLiteral extends LogicItem {
     toEmbeddedTS(state?: TranslatorState, isRequired?: boolean): string {
         let code = '';
         if (typeof this.value === 'string') {
-            code += `'StringLiteral'`;
+            code += `new nasl.core.String('StringLiteral')`;
         } else {
             code += isRequired ? '__IDENTIFIER__' : `''`;
         }
@@ -120,7 +127,7 @@ export class StringLiteral extends LogicItem {
      * @returns
      */
     public static getDefaultOptions(): any {
-        return { value: '文本' };
+        return { value: '' };
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/StructureProperty__.ts

@@ -1,7 +1,6 @@
 import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
-
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -19,9 +18,9 @@ import Module from './Module__';
 import App from './App__';
 
 /**
- * 数据结构字段
+ * 数据结构属性
  */
-@concept('数据结构字段')
+@concept('数据结构属性')
 export class StructureProperty extends BaseNode {
     /**
      * 产品概念
@@ -30,19 +29,19 @@ export class StructureProperty extends BaseNode {
     concept: 'StructureProperty' = 'StructureProperty';
 
     /**
-     * 数据结构字段名称
+     * 数据结构属性名称
      */
     @property()
     name: string = undefined;
 
     /**
-     * 数据结构字段标题
+     * 数据结构属性标题
      */
     @property()
     label: string = undefined;
 
     /**
-     * 数据结构字段描述
+     * 数据结构属性描述
      */
     @property()
     description: string = undefined;
@@ -109,7 +108,7 @@ export class StructureProperty extends BaseNode {
         return params;
     }
     /**
-     * 设置数据结构字段名称
+     * 设置数据结构属性名称
      */
     setName(name: string) {
         const object = {
@@ -122,7 +121,7 @@ export class StructureProperty extends BaseNode {
     }
 
     /**
-     * 设置数据结构字段标题
+     * 设置数据结构属性标题
      */
     setLabel(label: string) {
         const object = {
@@ -134,7 +133,7 @@ export class StructureProperty extends BaseNode {
     }
 
     /**
-     * 设置数据结构字段描述
+     * 设置数据结构属性描述
      */
     setDescription(description: string) {
         const object = {
@@ -169,10 +168,14 @@ export class StructureProperty extends BaseNode {
         });
     }
 
+
+
+
+
     /**
-     * 删除类型标注
-     * @param name 类型标注名称
-     */
+    * 删除类型标注
+    * @param name 类型标注名称
+    */
     removeTypeAnnotation(name: string): void;
 
     /**
@@ -243,24 +246,24 @@ export class StructureProperty 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' || typeNamespace === 'nasl.auth') {
-                    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') {
                 // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
                 // }
-                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') {