@lcap/nasl 1.0.0-alpha.2 → 1.0.0-alpha.3

package/src/concepts/CallLogic__.ts

@@ -1,6 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Logic from './Logic__';
 import Param from './Param__';
+import { ElementToVueOptions } from './ViewElement__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -9,8 +10,10 @@ 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 TypeAnnotation from './TypeAnnotation__';
 import Argument from './Argument__';
 import LogicItem from './LogicItem__';
 
@@ -49,12 +52,20 @@ export class CallLogic extends LogicItem {
     @property()
     shortcut: boolean = undefined;
 
+    /**
+     * 类型参数
+     */
+    @property('TypeAnnotation')
+    typeArguments?: Array<TypeAnnotation> = null;
+
     /**
      * 实际参数
      */
     @property('Argument')
     arguments: Array<Argument> = [];
 
+    
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -68,6 +79,120 @@ export class CallLogic extends LogicItem {
         return super.from(source, parentNode, parentKey) as CallLogic;
     }
 
+    
+    
+
+    
+
+    
+
+    /**
+    * 插入类型标注
+    * @internal
+    * @param typeAnnotationOptions 类型标注参数
+    */
+    _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+    /**
+    * 插入类型标注
+    * @internal
+    * @param typeAnnotation 已有的类型标注实例
+    */
+    _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+    _insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const typeAnnotationOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+        let typeAnnotation: TypeAnnotation;
+        if (options instanceof TypeAnnotation) {
+            options.delete(); // 同一实例不支持多处存在
+            typeAnnotation = options;
+            Object.assign(typeAnnotation, relationOptions);
+        } else {
+            typeAnnotation = TypeAnnotation.from({
+                ...typeAnnotationOptions,
+                ...options,
+            }, this, 'typeArguments');
+        }
+        this.typeArguments.splice(index, 0, typeAnnotation);
+        return typeAnnotation;
+    }
+
+    
+
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+    insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const node = this._insertTypeAnnotationAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'typeArguments',
+        });
+        return node;
+    }
+
+    
+
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+    _addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const index = this.typeArguments.length;
+        return this._insertTypeAnnotationAt(options as any, index);
+    }
+
+    
+
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+    addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const node = this._addTypeAnnotation(options as any);
+        const index = this.typeArguments.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'typeArguments',
+        });
+        return node;
+    }
+
+
+
+
+    
+
     /**
     * 插入实际参数
     * @internal
@@ -100,6 +225,8 @@ export class CallLogic extends LogicItem {
         return argument;
     }
 
+    
+
     /**
      * 插入实际参数
      * @param argumentOptions 实际参数参数
@@ -122,6 +249,8 @@ export class CallLogic extends LogicItem {
         return node;
     }
 
+    
+
     /**
      * 添加实际参数
      * @internal
@@ -141,6 +270,8 @@ export class CallLogic extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
+    
+
     /**
      * 添加实际参数
      * @param argumentOptions 实际参数参数
@@ -164,6 +295,45 @@ export class CallLogic extends LogicItem {
         return node;
     }
 
+
+    
+
+    /**
+     * 删除类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+
+    removeTypeAnnotation(options: TypeAnnotation) {
+        let typeAnnotation: TypeAnnotation = options;
+        return typeAnnotation.delete();
+    }
+
+    __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
+        const parentKey = typeAnnotation.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: typeAnnotation,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(typeAnnotation);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === typeAnnotation) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -171,7 +341,7 @@ export class CallLogic extends LogicItem {
     removeArgument(argument: Argument): void;
 
     removeArgument(options: Argument) {
-        const argument: Argument = options;
+        let argument: Argument = options;
         return argument.delete();
     }
 
@@ -214,15 +384,16 @@ export class CallLogic extends LogicItem {
     }
     get calleeKey(): string {
         const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.calleeName;
         if (!tsCalleeNamespace) {
-            return `logics.${this.calleeName}`;
+            return calleeName ? `logics.${calleeName}` : '__IDENTIFIER__';
         }
         // elements单独处理相对路径，和后缀的问题
         if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
             const methodName = tsCalleeNamespace.substring(0, tsCalleeNamespace.length - '.logics'.length);
-            return '__' + methodName + `.${this.calleeName}`;
+            return '__' + methodName + `.${calleeName}`;
         }
-        return `${tsCalleeNamespace}.${this.calleeName}`;
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
     }
 
     /**
@@ -265,6 +436,12 @@ export class CallLogic extends LogicItem {
                 keyword: param.name,
             });
         });
+        if (logic.typeParams) {
+            this.typeArguments = [];
+            logic.typeParams.forEach(() => {
+                this._addTypeAnnotation({});
+            });
+        }
     }
 
     setCallee(logic: Logic) {
@@ -278,10 +455,20 @@ export class CallLogic extends LogicItem {
             Object.assign(argument, relationOptions);
             return argument;
         });
+        let typeArguments = null;
+        if (logic.typeParams) {
+            typeArguments = logic.typeParams.map(() => {
+                const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+                const typeArgu = new TypeAnnotation();
+                Object.assign(typeArgu, relationOptions);
+                return typeArgu;
+            });
+        }
         this.update({
             calleeNamespace,
             calleeName,
             arguments: params,
+            typeArguments,
         });
     }
 
@@ -330,11 +517,11 @@ export class CallLogic extends LogicItem {
         });
     }
 
-    toVue(): string {
+    toVue(options?: ElementToVueOptions): string {
         let code = this.calleeName;
         code += '(';
         this.arguments.forEach((arg, index) => {
-            code += arg.toVue();
+            code += arg.toVue(options);
             if (index !== this.arguments.length - 1)
                 code += ', ';
         });
@@ -357,7 +544,11 @@ export class CallLogic extends LogicItem {
 
     toJS(state?: TranslatorState): string {
         let code = 'await ';
+        // 页面逻辑
         let isViewLogic = true;
+        // 组件逻辑
+        let isComponentLogic = false;
+        let componentName = '';
         const calleeNamespace = this.calleeNamespace;
         // calleeNamespace不存在，一定是页面逻辑
         if (calleeNamespace) {
@@ -368,6 +559,9 @@ export class CallLogic extends LogicItem {
                 if (!keywordViews) {
                     isViewLogic = false;
                 }
+            } else if (start === 'elements' && namespaceArr.length === 2 && namespaceArr[1] === 'logics') {
+                isComponentLogic = true;
+                componentName = namespaceArr[0];
             }
         }
         // 全局逻辑
@@ -383,10 +577,13 @@ export class CallLogic extends LogicItem {
             const namespaceArr = calleeNamespace.split('.');
             // 去掉app
             namespaceArr.shift();
-            const keywordEntities = namespaceArr.map((namespaceItem, index) => ({
-                key: namespaceItem,
-                index,
-            })).filter((namespaceItem, index) => index % 2 === 0).find((namespaceItem) => namespaceItem.key === 'entities');
+            const keywordEntities = namespaceArr
+                .map((namespaceItem, index) => ({
+                    key: namespaceItem,
+                    index,
+                }))
+                .filter((namespaceItem, index) => index % 2 === 0)
+                .find((namespaceItem) => namespaceItem.key === 'entities');
             const entityName = namespaceArr[keywordEntities?.index + 1];
 
             if (entityName) {
@@ -429,7 +626,9 @@ export class CallLogic extends LogicItem {
             }
             code += '\n})';
         } else {
-            if (calleeNamespace === 'nasl.ui.logics' || calleeNamespace === 'nasl.util.logics') {
+            if (isComponentLogic) {
+                code += `this.$refs.${componentName}.${this.calleeName}`;
+            } else if (calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') {
                 switch (this.calleeName) {
                     case 'showMessage':
                         code += `this.$toast.show`;
@@ -478,7 +677,7 @@ export class CallLogic extends LogicItem {
     //================================================================================
 }
 
-classMap.CallLogic = CallLogic;
+classMap['CallLogic'] = CallLogic;
 export default CallLogic;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/CallQueryComponent__.ts

@@ -12,6 +12,7 @@ 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 TypeAnnotation from './TypeAnnotation__';
@@ -198,7 +199,7 @@ export class CallQueryComponent extends LogicItem {
 
         getQueryGroupByExpressionExistingNames(excludedList: Array<QueryGroupByExpression> = []) {
         const excludedSet = new Set(excludedList);
-        return this.groupBy.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.groupBy || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getQueryGroupByExpressionUniqueName(name = 'queryGroupByExpression1') {
         return utils.unique(name, this.getQueryGroupByExpressionExistingNames());

package/src/concepts/Comment__.ts

@@ -7,6 +7,7 @@ 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__';

package/src/concepts/CompletionProperty__.ts

@@ -7,6 +7,7 @@ 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 TypeAnnotation from './TypeAnnotation__';

package/src/concepts/ConfigGroup__.ts

@@ -0,0 +1,290 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 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 ConfigProperty from './ConfigProperty__';
+import App from './App__';
+
+/**
+ * 配置组
+ */
+@concept
+export class ConfigGroup extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'ConfigGroup' = 'ConfigGroup';
+
+    /**
+     * 配置组名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 配置属性列表
+     */
+    @property('ConfigProperty')
+    properties: Array<ConfigProperty> = [];
+
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ConfigGroup>) {
+        source = Object.assign({}, ConfigGroup.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): ConfigGroup {
+        return super.from(source, parentNode, parentKey) as ConfigGroup;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeConfigGroup?.(this);
+        }
+        return params;
+    }
+    /**
+     * 设置配置组名称
+     */
+    setName(name: string) {
+        const object = {
+            name,
+        };
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
+
+        getConfigPropertyExistingNames(excludedList: Array<ConfigProperty> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getConfigPropertyUniqueName(name = 'configProperty1') {
+        return utils.unique(name, this.getConfigPropertyExistingNames());
+    }
+
+    /**
+    * 插入配置属性
+    * @internal
+    * @param name 配置属性名称，如果不填会自动生成一个唯一名称
+    */
+    _insertConfigPropertyAt(name: string, index: number): ConfigProperty;
+
+    /**
+    * 插入配置属性
+    * @internal
+    * @param configPropertyOptions 配置属性参数
+    */
+    _insertConfigPropertyAt(configPropertyOptions: Partial<ConfigProperty>, index: number): ConfigProperty;
+
+    /**
+    * 插入配置属性
+    * @internal
+    * @param configProperty 已有的配置属性实例
+    */
+    _insertConfigPropertyAt(configProperty: ConfigProperty, index: number): ConfigProperty;
+
+    _insertConfigPropertyAt(options: string | Partial<ConfigProperty> | ConfigProperty, index: number) {
+        const configPropertyOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'properties' };
+        let configProperty: ConfigProperty;
+        if (!options) {
+            configProperty = ConfigProperty.from({
+                ...configPropertyOptions,
+                name: this.getConfigPropertyUniqueName(),
+            }, this, 'properties');
+        } else if (typeof options === 'string') {
+            configProperty = ConfigProperty.from({
+                ...configPropertyOptions,
+                name: options,
+            }, this, 'properties');
+        } else if (options instanceof ConfigProperty) {
+            options.delete(); // 同一实例不支持多处存在
+            configProperty = options;
+            Object.assign(configProperty, relationOptions);
+        } else {
+            configProperty = ConfigProperty.from({
+                ...configPropertyOptions,
+                ...options,
+            }, this, 'properties');
+        }
+        this.properties.splice(index, 0, configProperty);
+        return configProperty;
+    }
+
+    /**
+     * 插入配置属性
+     * @param name 配置属性名称，如果不填会自动生成一个唯一名称
+     */
+    insertConfigPropertyAt(name: string, index: number): ConfigProperty;
+
+    /**
+     * 插入配置属性
+     * @param configPropertyOptions 配置属性参数
+     */
+    insertConfigPropertyAt(configPropertyOptions: Partial<ConfigProperty>, index: number): ConfigProperty;
+
+    /**
+     * 插入配置属性
+     * @param configProperty 已有的配置属性实例
+     */
+    insertConfigPropertyAt(configProperty: ConfigProperty, index: number): ConfigProperty;
+
+    insertConfigPropertyAt(options: string | Partial<ConfigProperty> | ConfigProperty, index: number) {
+        const node = this._insertConfigPropertyAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'properties',
+        });
+        return node;
+    }
+
+    /**
+     * 添加配置属性
+     * @internal
+     * @param name 配置属性名称，如果不填会自动生成一个唯一名称
+     */
+    _addConfigProperty(name?: string): ConfigProperty;
+
+    /**
+     * 添加配置属性
+     * @internal
+     * @param configPropertyOptions 配置属性参数
+     */
+    _addConfigProperty(configPropertyOptions: Partial<ConfigProperty>): ConfigProperty;
+
+    /**
+     * 添加配置属性
+     * @internal
+     * @param configProperty 已有的配置属性实例
+     */
+    _addConfigProperty(configProperty: ConfigProperty): ConfigProperty;
+
+    _addConfigProperty(options?: string | Partial<ConfigProperty> | ConfigProperty) {
+        const index = this.properties.length;
+        return this._insertConfigPropertyAt(options as any, index);
+    }
+
+    /**
+     * 添加配置属性
+     * @internal
+     * @param name 配置属性名称，如果不填会自动生成一个唯一名称
+     */
+    addConfigProperty(name?: string): ConfigProperty;
+
+    /**
+     * 添加配置属性
+     * @param configPropertyOptions 配置属性参数
+     */
+    addConfigProperty(configPropertyOptions: Partial<ConfigProperty>): ConfigProperty;
+
+    /**
+     * 添加配置属性
+     * @param configProperty 已有的配置属性实例
+     */
+    addConfigProperty(configProperty: ConfigProperty): ConfigProperty;
+
+    addConfigProperty(options?: string | Partial<ConfigProperty> | ConfigProperty) {
+        const node = this._addConfigProperty(options as any);
+        const index = this.properties.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'properties',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除配置属性
+    * @param name 配置属性名称
+    */
+    removeConfigProperty(name: string): void;
+
+    /**
+     * 删除配置属性
+     * @param configProperty 已有的配置属性实例
+     */
+    removeConfigProperty(configProperty: ConfigProperty): void;
+
+    removeConfigProperty(options: string | ConfigProperty) {
+        let configProperty: ConfigProperty;
+        if (typeof options === 'string') {
+            configProperty = this.properties.find((item) => item.name === options);
+            if (!configProperty) {
+                throw new Error('找不到配置属性 ' + options);
+            }
+        } else {
+            configProperty = options;
+        }
+        return configProperty.delete();
+    }
+
+    __removeConfigProperty(configProperty: ConfigProperty) {
+        const parentKey = configProperty.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: configProperty,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(configProperty);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === configProperty) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['ConfigGroup'] = ConfigGroup;
+export default ConfigGroup;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================