@lcap/nasl 3.6.4-beta.3 → 3.6.4-beta.4

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

@@ -0,0 +1,264 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
+import LogicItem from './LogicItem__';
+import TypeAnnotation from './TypeAnnotation__';
+/**
+ * 匹配分支
+ */
+export declare class MatchCase extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'MatchCase';
+    /**
+     * then
+     */
+    body: Array<LogicItem>;
+    /**
+     * 条件表达式
+     */
+    patterns: Array<LogicItem | TypeAnnotation>;
+    /**
+     * 是否可枚举
+     */
+    isMatchedTypeEnumable: boolean;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<MatchCase>);
+    static from(source: any, parentNode?: any, parentKey?: string): MatchCase;
+    /**
+     * 设置条件表达式
+     */
+    setPatterns(patterns: Array<LogicItem | TypeAnnotation>): void;
+    /**
+     * 设置是否可枚举
+     */
+    setIsMatchedTypeEnumable(isMatchedTypeEnumable: boolean): void;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInBody(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInBody(logicItem: LogicItem): LogicItem;
+    getLogicItemExistingNames(excludedList?: Array<LogicItem>): string[];
+    getLogicItemUniqueName(name?: string): string;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    _insertLogicItemInPatternsAt(name: string, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertLogicItemInPatternsAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertLogicItemInPatternsAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    insertLogicItemInPatternsAt(name: string, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertLogicItemInPatternsAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertLogicItemInPatternsAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    _addLogicItemInPatterns(name?: string): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addLogicItemInPatterns(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addLogicItemInPatterns(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    addLogicItemInPatterns(name?: string): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addLogicItemInPatterns(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addLogicItemInPatterns(logicItem: LogicItem): LogicItem;
+    getTypeAnnotationExistingNames(excludedList?: Array<TypeAnnotation>): string[];
+    getTypeAnnotationUniqueName(name?: string): string;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param name 类型标注名称，如果不填会自动生成一个唯一名称
+     */
+    _insertTypeAnnotationAt(name: string, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param name 类型标注名称，如果不填会自动生成一个唯一名称
+     */
+    insertTypeAnnotationAt(name: string, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param name 类型标注名称，如果不填会自动生成一个唯一名称
+     */
+    _addTypeAnnotation(name?: string): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param name 类型标注名称，如果不填会自动生成一个唯一名称
+     */
+    addTypeAnnotation(name?: string): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInBody(logicItem: LogicItem): void;
+    /**
+     * 删除逻辑项
+     * @param name 逻辑项名称
+     */
+    removeLogicItemInPatterns(name: string): void;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeLogicItemInPatterns(logicItem: LogicItem): void;
+    /**
+     * 删除类型标注
+     * @param name 类型标注名称
+     */
+    removeTypeAnnotation(name: string): void;
+    /**
+     * 删除类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+    get isDisabled(): boolean;
+    get isSlotTypeError(): boolean;
+    isTypeMatching(): Promise<boolean>;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(expression: LogicItem, index?: number, length?: number): string;
+    toEmbeddedTS(state?: TranslatorState, index?: number, parentCode?: string): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState, index?: number, parentCode?: string): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default MatchCase;

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

@@ -0,0 +1,122 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type TypeAnnotation from './TypeAnnotation__';
+import { EventPayload } from '../common/EventEmitter';
+import LogicItem from './LogicItem__';
+import MatchCase from './MatchCase__';
+/**
+ * 匹配
+ */
+export declare class Match extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Match';
+    /**
+     * 逻辑项
+     */
+    expression: LogicItem;
+    /**
+     * 是否表达式形态
+     */
+    isExpression: boolean;
+    /**
+     * 匹配分支列表
+     */
+    cases: Array<MatchCase>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Match>);
+    static from(source: any, parentNode?: any, parentKey?: string): Match;
+    /**
+     * 插入匹配分支
+     * @internal
+     * @param matchCaseOptions 匹配分支参数
+     */
+    _insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
+    /**
+     * 插入匹配分支
+     * @internal
+     * @param matchCase 已有的匹配分支实例
+     */
+    _insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
+    /**
+     * 插入匹配分支
+     * @param matchCaseOptions 匹配分支参数
+     */
+    insertMatchCaseAt(matchCaseOptions: Partial<MatchCase>, index: number): MatchCase;
+    /**
+     * 插入匹配分支
+     * @param matchCase 已有的匹配分支实例
+     */
+    insertMatchCaseAt(matchCase: MatchCase, index: number): MatchCase;
+    /**
+     * 添加匹配分支
+     * @internal
+     * @param matchCaseOptions 匹配分支参数
+     */
+    _addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
+    /**
+     * 添加匹配分支
+     * @internal
+     * @param matchCase 已有的匹配分支实例
+     */
+    _addMatchCase(matchCase: MatchCase): MatchCase;
+    /**
+     * 添加匹配分支
+     * @param matchCaseOptions 匹配分支参数
+     */
+    addMatchCase(matchCaseOptions: Partial<MatchCase>): MatchCase;
+    /**
+     * 添加匹配分支
+     * @param matchCase 已有的匹配分支实例
+     */
+    addMatchCase(matchCase: MatchCase): MatchCase;
+    /**
+     * 删除匹配分支
+     * @param matchCase 已有的匹配分支实例
+     */
+    removeMatchCase(matchCase: MatchCase): void;
+    enumerableItems: Array<LogicItem | TypeAnnotation>;
+    get isEnumerable(): boolean;
+    cacheStatus(): Promise<void>;
+    /**
+     * 是否允许新建case
+     */
+    get canAddCase(): boolean;
+    getEnumerableItems(typeAnnotation?: TypeAnnotation): Promise<LogicItem[] | TypeAnnotation[]>;
+    setIsExpression(isExpression: boolean): void;
+    /**
+     * 设置逻辑项
+     */
+    setExpression(expression: LogicItem): void;
+    setExpressionWitchCase(expression: LogicItem): Promise<void>;
+    autoGenCases(oldExpression: LogicItem): Promise<void>;
+    autoGenCasesAST({ oldAst, cacheType }: any): Promise<void>;
+    changeGenCases(): Promise<void>;
+    static getDefaultOptions(): {
+        label: string;
+    };
+    isTypeMatching(): Promise<boolean>;
+    onChange($event?: EventPayload): void;
+    get expressionNameInView(): string;
+    getViewMatchExpressionBuilder(): string;
+    getInViewMethod(state?: TranslatorState): string;
+    setIsExpressionCustom(isExpression: boolean): void;
+    toVue(state?: TranslatorState): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(state?: TranslatorState): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default Match;

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

@@ -0,0 +1,64 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import { TypeAnnotation } from '..';
+import { ElementToVueOptions } from './ViewElement__';
+import LogicItem from './LogicItem__';
+/**
+ * 成员表达式
+ */
+export declare class MemberExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'MemberExpression';
+    /**
+     * 逻辑项
+     */
+    object: LogicItem;
+    /**
+     * 逻辑项
+     */
+    property: LogicItem;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<MemberExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): MemberExpression;
+    typeAnnotation: TypeAnnotation;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(state?: TranslatorState): string;
+    toBrief(): string;
+    setValue(newValue: string): void;
+    /**
+     * 设置数据结构属性名称
+     */
+    setName(name: string): void;
+    isEnum(): boolean;
+    isDefaultValueExpression(getVuePrototype: boolean): boolean;
+    getValue(): string;
+    transfromAtrrLogic(options?: {
+        type: 'toVue' | 'toJS';
+    }): string;
+    get completeName(): string;
+    get rootName(): string;
+    /**
+     * 翻译
+     * @param state
+     * @returns
+     */
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    get lastObject(): any;
+    firstMemberExpressionNode(): any;
+}
+export default MemberExpression;

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

@@ -0,0 +1,220 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import Module from './Module__';
+import BaseNode from '../common/BaseNode';
+import TypeAnnotation from './TypeAnnotation__';
+import ValidationRule from './ValidationRule__';
+import LogicItem from './LogicItem__';
+/**
+ * 元数据类型
+ */
+export declare class MetadataType extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'MetadataType';
+    /**
+     * 名称
+     */
+    name: string;
+    /**
+     * 标题
+     */
+    label: string;
+    /**
+     * 描述
+     */
+    description: string;
+    /**
+     * 类型
+     */
+    typeAnnotation: TypeAnnotation;
+    /**
+     * 验证规则
+     */
+    rules: Array<ValidationRule>;
+    /**
+     * 草稿态
+     */
+    playground: Array<LogicItem>;
+    /**
+     * 唯一标识
+     */
+    uuid: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<MetadataType>);
+    static from(source: any, parentNode?: any, parentKey?: string): MetadataType;
+    getValidationRuleExistingNames(excludedList?: Array<ValidationRule>): string[];
+    getValidationRuleUniqueName(name?: string): string;
+    /**
+     * 插入验证规则
+     * @internal
+     * @param name 验证规则名称，如果不填会自动生成一个唯一名称
+     */
+    _insertValidationRuleAt(name: string, index: number): ValidationRule;
+    /**
+     * 插入验证规则
+     * @internal
+     * @param validationRuleOptions 验证规则参数
+     */
+    _insertValidationRuleAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
+    /**
+     * 插入验证规则
+     * @internal
+     * @param validationRule 已有的验证规则实例
+     */
+    _insertValidationRuleAt(validationRule: ValidationRule, index: number): ValidationRule;
+    /**
+     * 插入验证规则
+     * @param name 验证规则名称，如果不填会自动生成一个唯一名称
+     */
+    insertValidationRuleAt(name: string, index: number): ValidationRule;
+    /**
+     * 插入验证规则
+     * @param validationRuleOptions 验证规则参数
+     */
+    insertValidationRuleAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
+    /**
+     * 插入验证规则
+     * @param validationRule 已有的验证规则实例
+     */
+    insertValidationRuleAt(validationRule: ValidationRule, index: number): ValidationRule;
+    /**
+     * 添加验证规则
+     * @internal
+     * @param name 验证规则名称，如果不填会自动生成一个唯一名称
+     */
+    _addValidationRule(name?: string): ValidationRule;
+    /**
+     * 添加验证规则
+     * @internal
+     * @param validationRuleOptions 验证规则参数
+     */
+    _addValidationRule(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
+    /**
+     * 添加验证规则
+     * @internal
+     * @param validationRule 已有的验证规则实例
+     */
+    _addValidationRule(validationRule: ValidationRule): ValidationRule;
+    /**
+     * 添加验证规则
+     * @internal
+     * @param name 验证规则名称，如果不填会自动生成一个唯一名称
+     */
+    addValidationRule(name?: string): ValidationRule;
+    /**
+     * 添加验证规则
+     * @param validationRuleOptions 验证规则参数
+     */
+    addValidationRule(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
+    /**
+     * 添加验证规则
+     * @param validationRule 已有的验证规则实例
+     */
+    addValidationRule(validationRule: ValidationRule): ValidationRule;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItem(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItem(logicItem: LogicItem): LogicItem;
+    /**
+     * 删除验证规则
+     * @param name 验证规则名称
+     */
+    removeValidationRule(name: string): void;
+    /**
+     * 删除验证规则
+     * @param validationRule 已有的验证规则实例
+     */
+    removeValidationRule(validationRule: ValidationRule): void;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItem(logicItem: LogicItem): void;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    /**
+     * 是否可编辑
+     *
+     */
+    get readonly(): boolean;
+    deleteLogincAndModule(): void;
+    /**
+     * 设置元数据名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置元数据标题
+     */
+    setLabel(label: string): void;
+    /**
+     * 设置元数据描述
+     */
+    setDescription(description: string): void;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    getNamespace(): string;
+    getTsNamespace(): string;
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name?: string): string;
+    toEmbeddedTSFile(): EmbeddedTSFileGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default MetadataType;