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

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

@@ -0,0 +1,76 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import App from './App__';
+import Module from './Module__';
+import BaseNode from '../common/BaseNode';
+import Identifier from './Identifier__';
+/**
+ * 触发器启动器
+ */
+export declare class TriggerLauncher extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'TriggerLauncher' | 'ConnectorTriggerLauncher' | 'MsgTriggerLauncher';
+    /**
+     * 触发器启动器名称
+     */
+    name: string;
+    /**
+     * calleeNamespace
+     */
+    calleeNamespace: string;
+    /**
+     * calleeName
+     */
+    calleeName: string;
+    /**
+     * callBackLogic
+     */
+    callBackLogic: Identifier;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<TriggerLauncher>);
+    static from(source: any, parentNode?: any, parentKey?: string): TriggerLauncher;
+    /**
+     * 设置触发器启动器名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置calleeNamespace
+     */
+    setCalleeNamespace(calleeNamespace: string): void;
+    /**
+     * 设置calleeName
+     */
+    setCalleeName(calleeName: string): void;
+    /**
+     * 设置callBackLogic
+     */
+    setCallBackLogic(callBackLogic: Identifier): void;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    get callBackLogicKey(): string;
+    toEmbeddedTSFile(): EmbeddedTSFileGenerator;
+    getTsNamespace(): string;
+    static getEmbeddedFileBasePath(app: App): string;
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name?: string): string;
+}
+export default TriggerLauncher;

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

@@ -0,0 +1,303 @@
+import type App from './App__';
+import type Structure from './Structure__';
+import { TranslatorState, TranslatorGenerator } from '../translator';
+export declare enum PRIMITIVE_TYPE {
+    Boolean = "Boolean",
+    Integer = "Integer",
+    Long = "Long",
+    Double = "Double",
+    Decimal = "Decimal",
+    String = "String",
+    Text = "Text",
+    Binary = "Binary",
+    Date = "Date",
+    Time = "Time",
+    DateTime = "DateTime",
+    Email = "Email",
+    Union = "Union",
+    Null = "Null"
+}
+export declare const PRIMITIVE_TITLE: Record<string, string>;
+export declare const OLD_PRIMITIVE_TITLE: Record<string, string>;
+export declare const PRIMITIVE_DESC: Record<string, string>;
+export declare const GENERIC_DESC: Record<string, string>;
+/**
+ * 判断是否是联合类型
+ * @param typeAnnotation
+ * @returns
+ */
+export declare function isUnion(typeAnnotation: TypeAnnotation): boolean;
+import * as types from './utils/types';
+import BaseNode from '../common/BaseNode';
+import StructureProperty from './StructureProperty__';
+/**
+ * 类型标注
+ */
+export declare class TypeAnnotation extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'TypeAnnotation';
+    /**
+     * 类型种类
+     */
+    typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure';
+    /**
+     * 类型命名空间
+     */
+    typeNamespace: string;
+    /**
+     * 类型名称
+     */
+    typeName: string;
+    /**
+     * 类型参数
+     */
+    typeArguments?: Array<TypeAnnotation>;
+    /**
+     * 返回类型
+     */
+    returnType?: Array<TypeAnnotation>;
+    /**
+     * 是否是推断出来的
+     */
+    inferred: boolean;
+    /**
+     * 匿名数据结构属性
+     */
+    properties?: Array<StructureProperty>;
+    /**
+     * 规则对象
+     */
+    ruleMap: Map<string, number>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<TypeAnnotation>);
+    static from(source: any, parentNode?: any, parentKey?: string): TypeAnnotation;
+    /**
+     * 设置规则对象
+     */
+    setRuleMap(ruleMap: Map<string, number>): void;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 插入数据结构属性
+     * @internal
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    _insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @internal
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    _insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    _addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    _addStructureProperty(structureProperty: StructureProperty): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @param structurePropertyOptions 数据结构属性参数
+     */
+    addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    addStructureProperty(structureProperty: StructureProperty): StructureProperty;
+    /**
+     * 删除类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
+    /**
+     * 删除类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
+    /**
+     * 删除数据结构属性
+     * @param structureProperty 已有的数据结构属性实例
+     */
+    removeStructureProperty(structureProperty: StructureProperty): void;
+    longNotInteger: boolean;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    traverse(callback: (arg: TypeAnnotation) => void, enter: (arg: TypeAnnotation) => void, leave: (arg: TypeAnnotation) => void, onJoin: (arg: TypeAnnotation, arg2: TypeAnnotation) => void): void;
+    get typeKey(): string;
+    get sortedTypeKey(): string;
+    /**
+     * 用于展示的 type 标题
+     */
+    get headTitle(): string;
+    /**
+     * 用于展示的 type 标题
+     */
+    get typeTitle(): string;
+    /**
+     * 用于展示的 无中文的精简type标题
+     */
+    get typeInlineTitle(): string;
+    /**
+     * 用于展示的 纯中文的type 标题
+     */
+    get typeChineseTitle(): string;
+    get typeTitleList(): any[];
+    static createPrimitive(typeName: string, source?: Partial<TypeAnnotation>): TypeAnnotation;
+    static createReference(typeName: string, source?: Partial<TypeAnnotation>): TypeAnnotation;
+    static createGeneric(typeName: string, source?: Partial<TypeAnnotation>): TypeAnnotation;
+    static createTypeParam(typeName: string, source?: Partial<TypeAnnotation>): TypeAnnotation;
+    static createTypeAnonymousStructure(properties: Array<StructureProperty>, source?: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 设置类型属性名称
+     */
+    setTypeName(typeName: string): void;
+    /**
+     * 设置类型属性名称
+     */
+    setTypeNamespace(typeNamespace: string): void;
+    get tsCalleeNamespace(): string;
+    get integration(): types.SyntaxNode;
+    get connector(): types.SyntaxNode;
+    toVue(state?: TranslatorState): string;
+    toJS(state?: TranslatorState): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    /**
+     * 用于标准化数据结构，便于计算 anonymousStructure 的 __name
+     */
+    get anonymousStructureTypeDesc(): string;
+    /**
+     * hash 用于比较 anonymousStructure 是否相同
+     */
+    get hash(): string;
+    getDefaultValue(value: string): string;
+    /**
+     *
+     * @param code 233
+     *
+     */
+    static recognize(code: string | number): TypeAnnotation;
+    typeArgumentsPush(typeItem: TypeAnnotation): void;
+    isComplexType(): boolean;
+    get sign(): string;
+    isSame(typeAnnotation: TypeAnnotation): boolean;
+    isSystemType(): boolean;
+    hasSystemType(app: App, structureCache?: Set<Structure>): boolean;
+}
+export default TypeAnnotation;

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

@@ -0,0 +1,34 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import BaseNode from '../common/BaseNode';
+/**
+ * 类型参数
+ */
+export declare class TypeParam extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'TypeParam';
+    /**
+     * 类型名称
+     */
+    name: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<TypeParam>);
+    static from(source: any, parentNode?: any, parentKey?: string): TypeParam;
+    useComponent: any;
+    toEmbeddedTS(state?: TranslatorState, prefix?: string): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default TypeParam;

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

@@ -0,0 +1,45 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
+import LogicItem from './LogicItem__';
+/**
+ * 一元表达式
+ */
+export declare class UnaryExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'UnaryExpression';
+    /**
+     * 参数
+     */
+    argument: LogicItem;
+    /**
+     * 运算符
+     */
+    operator: '!' | 'isNull';
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<UnaryExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): UnaryExpression;
+    /**
+     * 设置参数
+     */
+    setArgument(argument: LogicItem): void;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(state?: TranslatorState): string;
+    toBrief(): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+}
+export default UnaryExpression;

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

@@ -0,0 +1,41 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
+import LogicItem from './LogicItem__';
+/**
+ * 未解析的
+ */
+export declare class Unparsed extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Unparsed';
+    /**
+     * 表达式代码
+     */
+    code: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Unparsed>);
+    static from(source: any, parentNode?: any, parentKey?: string): Unparsed;
+    /**
+     * 设置表达式代码
+     */
+    setCode(code: string): void;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(state?: TranslatorState): string;
+    toBrief(): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(): string;
+}
+export default Unparsed;

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

@@ -0,0 +1,33 @@
+import BaseNode from '../common/BaseNode';
+/**
+ * IDE 中使用的编辑组件
+ */
+export declare class UseComponent extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'UseComponent';
+    /**
+     * type
+     */
+    type: string;
+    /**
+     * 需要传入的属性
+     */
+    attrs: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<UseComponent>);
+    static from(source: any, parentNode?: any, parentKey?: string): UseComponent;
+}
+export default UseComponent;

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

@@ -0,0 +1,133 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type Function from './Function__';
+import { ElementToVueOptions } from './ViewElement__';
+import Argument from './Argument__';
+import LogicItem from './LogicItem__';
+/**
+ * 验证规则
+ */
+export declare class ValidationRule extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'ValidationRule';
+    /**
+     * calleeNamespace
+     */
+    calleeNamespace: string;
+    /**
+     * calleeName
+     */
+    calleeName: string;
+    /**
+     * 实际参数
+     */
+    arguments: Array<Argument>;
+    /**
+     * 错误信息
+     */
+    errorMessage: LogicItem;
+    /**
+     * 验证对象
+     */
+    target: LogicItem;
+    /**
+     * 是否启用服务端验证
+     */
+    enableServerValidation: boolean;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ValidationRule>);
+    static from(source: any, parentNode?: any, parentKey?: string): ValidationRule;
+    /**
+     * 设置错误信息
+     */
+    setErrorMessage(errorMessage: LogicItem): void;
+    /**
+     * 设置验证对象
+     */
+    setTarget(target: LogicItem): void;
+    /**
+     * 设置是否启用服务端验证
+     */
+    setEnableServerValidation(enableServerValidation: boolean): void;
+    /**
+     * 插入实际参数
+     * @internal
+     * @param argumentOptions 实际参数参数
+     */
+    _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+    /**
+     * 插入实际参数
+     * @internal
+     * @param argument 已有的实际参数实例
+     */
+    _insertArgumentAt(argument: Argument, index: number): Argument;
+    /**
+     * 插入实际参数
+     * @param argumentOptions 实际参数参数
+     */
+    insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+    /**
+     * 插入实际参数
+     * @param argument 已有的实际参数实例
+     */
+    insertArgumentAt(argument: Argument, index: number): Argument;
+    /**
+     * 添加实际参数
+     * @internal
+     * @param argumentOptions 实际参数参数
+     */
+    _addArgument(argumentOptions: Partial<Argument>): Argument;
+    /**
+     * 添加实际参数
+     * @internal
+     * @param argument 已有的实际参数实例
+     */
+    _addArgument(argument: Argument): Argument;
+    /**
+     * 添加实际参数
+     * @param argumentOptions 实际参数参数
+     */
+    addArgument(argumentOptions: Partial<Argument>): Argument;
+    /**
+     * 添加实际参数
+     * @param argument 已有的实际参数实例
+     */
+    addArgument(argument: Argument): Argument;
+    /**
+     * 删除实际参数
+     * @param argument 已有的实际参数实例
+     */
+    removeArgument(argument: Argument): void;
+    static getDefaultOptions(): {
+        target: {
+            concept: string;
+            name: string;
+        };
+    };
+    toInViewMethod(): string;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(state?: TranslatorState): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    toBrief(): string;
+    get calleeKey(): string;
+    _setCallee(func: Function): void;
+    setCallee(func: Function): void;
+    getAllDefaultErrorMessage(): {}[];
+    get i18nKeyPrefix(): string;
+}
+export default ValidationRule;