@lcap/nasl 3.7.0-beta.3 → 3.7.0-beta.5

package/dist/src/concepts/Process__.d.ts

@@ -0,0 +1,605 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type Logic from './Logic__';
+import Module from './Module__';
+import { EventPayload } from '../common/EventEmitter';
+import BaseNode from '../common/BaseNode';
+import BindEvent from './BindEvent__';
+import Param from './Param__';
+import Return from './Return__';
+import Constant from './Constant__';
+import ProcessElement from './ProcessElement__';
+/**
+ * 流程
+ */
+export declare class Process extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Process';
+    /**
+     * 流程名称
+     */
+    name: string;
+    /**
+     * 流程标题
+     */
+    title: string;
+    /**
+     * 流程描述
+     */
+    description: string;
+    /**
+     * 元素绑定事件列表
+     */
+    bindEvents: Array<BindEvent>;
+    /**
+     * 输入参数列表
+     */
+    params: Array<Param>;
+    /**
+     * 输出参数列表
+     */
+    returns: Array<Return>;
+    /**
+     * 常量列表
+     */
+    constants: Array<Constant>;
+    /**
+     * 流程元素列表
+     */
+    elements: Array<ProcessElement>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Process>);
+    static from(source: any, parentNode?: any, parentKey?: string): Process;
+    /**
+     * 设置流程名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置流程标题
+     */
+    setTitle(title: string): void;
+    /**
+     * 设置流程描述
+     */
+    setDescription(description: string): void;
+    getBindEventExistingNames(excludedList?: Array<BindEvent>): string[];
+    getBindEventUniqueName(name?: string): string;
+    /**
+     * 插入元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    _insertBindEventAt(name: string, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @internal
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    _insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @internal
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    _insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    insertBindEventAt(name: string, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
+    /**
+     * 插入元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    _addBindEvent(name?: string): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    _addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    _addBindEvent(bindEvent: BindEvent): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    addBindEvent(name?: string): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    addBindEvent(bindEvent: BindEvent): BindEvent;
+    getParamExistingNames(excludedList?: Array<Param>): string[];
+    getParamUniqueName(name?: string): string;
+    /**
+     * 插入输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _insertParamAt(name: string, index: number): Param;
+    /**
+     * 插入输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+    /**
+     * 插入输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _insertParamAt(param: Param, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertParamAt(name: string, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param paramOptions 输入参数参数
+     */
+    insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param param 已有的输入参数实例
+     */
+    insertParamAt(param: Param, index: number): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addParam(name?: string): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _addParam(paramOptions: Partial<Param>): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _addParam(param: Param): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    addParam(name?: string): Param;
+    /**
+     * 添加输入参数
+     * @param paramOptions 输入参数参数
+     */
+    addParam(paramOptions: Partial<Param>): Param;
+    /**
+     * 添加输入参数
+     * @param param 已有的输入参数实例
+     */
+    addParam(param: Param): Param;
+    getReturnExistingNames(excludedList?: Array<Return>): string[];
+    getReturnUniqueName(name?: string): string;
+    /**
+     * 插入输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _insertReturnAt(name: string, index: number): Return;
+    /**
+     * 插入输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+    /**
+     * 插入输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _insertReturnAt(ret: Return, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertReturnAt(name: string, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param retOptions 输出参数参数
+     */
+    insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param ret 已有的输出参数实例
+     */
+    insertReturnAt(ret: Return, index: number): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addReturn(name?: string): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _addReturn(retOptions: Partial<Return>): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _addReturn(ret: Return): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    addReturn(name?: string): Return;
+    /**
+     * 添加输出参数
+     * @param retOptions 输出参数参数
+     */
+    addReturn(retOptions: Partial<Return>): Return;
+    /**
+     * 添加输出参数
+     * @param ret 已有的输出参数实例
+     */
+    addReturn(ret: Return): Return;
+    getConstantExistingNames(excludedList?: Array<Constant>): string[];
+    getConstantUniqueName(name?: string): string;
+    /**
+     * 插入常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    _insertConstantAt(name: string, index: number): Constant;
+    /**
+     * 插入常量
+     * @internal
+     * @param constantOptions 常量参数
+     */
+    _insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+    /**
+     * 插入常量
+     * @internal
+     * @param constant 已有的常量实例
+     */
+    _insertConstantAt(constant: Constant, index: number): Constant;
+    /**
+     * 插入常量
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    insertConstantAt(name: string, index: number): Constant;
+    /**
+     * 插入常量
+     * @param constantOptions 常量参数
+     */
+    insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+    /**
+     * 插入常量
+     * @param constant 已有的常量实例
+     */
+    insertConstantAt(constant: Constant, index: number): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    _addConstant(name?: string): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param constantOptions 常量参数
+     */
+    _addConstant(constantOptions: Partial<Constant>): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param constant 已有的常量实例
+     */
+    _addConstant(constant: Constant): Constant;
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    addConstant(name?: string): Constant;
+    /**
+     * 添加常量
+     * @param constantOptions 常量参数
+     */
+    addConstant(constantOptions: Partial<Constant>): Constant;
+    /**
+     * 添加常量
+     * @param constant 已有的常量实例
+     */
+    addConstant(constant: Constant): Constant;
+    getElementExistingNames(excludedList?: Array<ProcessElement>): string[];
+    getElementUniqueName(name?: string): string;
+    /**
+     * 插入流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    _insertElementAt(name: string, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @internal
+     * @param elementOptions 流程元素参数
+     */
+    _insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @internal
+     * @param element 已有的流程元素实例
+     */
+    _insertElementAt(element: ProcessElement, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    insertElementAt(name: string, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @param elementOptions 流程元素参数
+     */
+    insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
+    /**
+     * 插入流程元素
+     * @param element 已有的流程元素实例
+     */
+    insertElementAt(element: ProcessElement, index: number): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    _addElement(name?: string): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param elementOptions 流程元素参数
+     */
+    _addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param element 已有的流程元素实例
+     */
+    _addElement(element: ProcessElement): ProcessElement;
+    /**
+     * 添加流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    addElement(name?: string): ProcessElement;
+    /**
+     * 添加流程元素
+     * @param elementOptions 流程元素参数
+     */
+    addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
+    /**
+     * 添加流程元素
+     * @param element 已有的流程元素实例
+     */
+    addElement(element: ProcessElement): ProcessElement;
+    /**
+     * 删除元素绑定事件
+     * @param name 元素绑定事件名称
+     */
+    removeBindEvent(name: string): void;
+    /**
+     * 删除元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    removeBindEvent(bindEvent: BindEvent): void;
+    /**
+     * 删除输入参数
+     * @param name 输入参数名称
+     */
+    removeParam(name: string): void;
+    /**
+     * 删除输入参数
+     * @param param 已有的输入参数实例
+     */
+    removeParam(param: Param): void;
+    /**
+     * 删除输出参数
+     * @param name 输出参数名称
+     */
+    removeReturn(name: string): void;
+    /**
+     * 删除输出参数
+     * @param ret 已有的输出参数实例
+     */
+    removeReturn(ret: Return): void;
+    /**
+     * 删除常量
+     * @param name 常量名称
+     */
+    removeConstant(name: string): void;
+    /**
+     * 删除常量
+     * @param constant 已有的常量实例
+     */
+    removeConstant(constant: Constant): void;
+    /**
+     * 删除流程元素
+     * @param name 流程元素名称
+     */
+    removeElement(name: string): void;
+    /**
+     * 删除流程元素
+     * @param element 已有的流程元素实例
+     */
+    removeElement(element: ProcessElement): void;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    onChange($event?: EventPayload): void;
+    _removeElement(element: ProcessElement): {
+        propertyName: string;
+        index: number;
+    };
+    getVarExistingNames(excludedList?: Array<Param | Return | Constant | ProcessElement>): string[];
+    getNamespace(ns: string): string;
+    getEmbeddedFilePath(name?: string): string;
+    genExclusiveGatewayLogic(elem: ProcessElement): Logic;
+    get logics(): Logic[];
+    /**
+     * 获取当前逻辑下所有elements上bindEvents下的logic
+     */
+    elementLogicRoot: any[];
+    getElementLogicRoot(): void;
+    toUserTaskPropertyGetterTS(userTask: ProcessElement): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toEmbeddedTSFile(): EmbeddedTSFileGenerator;
+    static getDefaultOptions(): {
+        constants: {
+            concept: string;
+            name: string;
+            typeAnnotation: {
+                concept: string;
+                typeKind: string;
+                typeNamespace: string;
+                typeName: string;
+            };
+        }[];
+        elements: ({
+            concept: string;
+            name: string;
+            type: string;
+            title: string;
+            bounds: {
+                concept: string;
+                x: number;
+                y: number;
+            };
+            sourceRef?: undefined;
+            targetRef?: undefined;
+            waypoints?: undefined;
+        } | {
+            bounds: {
+                concept: string;
+                x: number;
+                y: number;
+            };
+            bindAttrs: {
+                concept: string;
+                name: string;
+                assignee: {
+                    concept: string;
+                };
+            }[];
+            constants: {
+                concept: string;
+                name: string;
+                typeAnnotation: {
+                    concept: string;
+                    typeKind: string;
+                    typeNamespace: string;
+                    typeName: string;
+                };
+            }[];
+            concept: string;
+            name: string;
+            type: string;
+            title: string;
+            sourceRef?: undefined;
+            targetRef?: undefined;
+            waypoints?: undefined;
+        } | {
+            bounds: {
+                concept: string;
+                x: number;
+                y: number;
+            };
+            bindAttrs: {
+                concept: string;
+                name: string;
+                assignee: {
+                    concept: string;
+                };
+            }[];
+            constants: {
+                concept: string;
+                name: string;
+                typeAnnotation: {
+                    concept: string;
+                    typeKind: string;
+                    typeNamespace: string;
+                    typeName: string;
+                };
+            }[];
+            concept: string;
+            name: string;
+            type: string;
+            title: string;
+            returns: {
+                concept: string;
+                description: string;
+                name: string;
+                typeAnnotation: {
+                    concept: string;
+                    typeKind: string;
+                    typeNamespace: string;
+                    typeName: string;
+                };
+            }[];
+            sourceRef?: undefined;
+            targetRef?: undefined;
+            waypoints?: undefined;
+        } | {
+            concept: string;
+            name: string;
+            type: string;
+            sourceRef: string;
+            targetRef: string;
+            waypoints: {
+                x: number;
+                y: number;
+            }[];
+            title?: undefined;
+            bounds?: undefined;
+        })[];
+    };
+}
+export default Process;

package/dist/src/concepts/PropDeclaration__.d.ts

@@ -0,0 +1,99 @@
+import BaseNode from '../common/BaseNode';
+import BaseSetter from './BaseSetter__';
+import DefaultValue from './DefaultValue__';
+/**
+ * 组件属性
+ */
+export declare class PropDeclaration extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'PropDeclaration';
+    /**
+     * 组件属性名称
+     */
+    name: string;
+    /**
+     * 组件属性标题
+     */
+    title: string;
+    /**
+     * 组件属性分组
+     */
+    group: '基础信息' | '数据属性' | '主要属性' | '交互属性' | '状态属性' | '样式属性' | '工具属性';
+    /**
+     * 组件属性图标
+     */
+    icon?: string;
+    /**
+     * 组件属性描述
+     */
+    description?: string;
+    /**
+     * 类型
+     */
+    tsType: string;
+    /**
+     * 是否支持双向绑定
+     */
+    sync: boolean;
+    /**
+     * 工具提示链接
+     */
+    tooltipLink?: string;
+    /**
+     * 文档描述
+     */
+    docDescription?: string;
+    /**
+     * 隐藏绑定属性按钮
+     */
+    bindHide: boolean;
+    /**
+     * 绑定属性并打开弹窗
+     */
+    bindOpen: boolean;
+    /**
+     * 所在的 tab 页
+     */
+    tabKind: 'property' | 'style';
+    /**
+     * 属性设置器
+     */
+    setter: BaseSetter;
+    /**
+     * 默认值
+     */
+    defaultValue?: DefaultValue;
+    /**
+     * 渲染时的设计值
+     */
+    tsDesignerValue?: string;
+    /**
+     * 是否显隐
+     */
+    tsIf?: string;
+    /**
+     * 是否禁用
+     */
+    tsDisabledIf?: string;
+    /**
+     * 在属性切换时发生的事件
+     */
+    tsOnChange?: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<PropDeclaration>);
+    static from(source: any, parentNode?: any, parentKey?: string): PropDeclaration;
+}
+export default PropDeclaration;