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

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

@@ -0,0 +1,224 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type Logic from './Logic__';
+import { GetCode, Range } from './utils/quick-info';
+import type { ElementToVueOptions } from './ViewElement__';
+import TypeAnnotation from './TypeAnnotation__';
+import Argument from './Argument__';
+import BindAttribute from './BindAttribute__';
+import LogicItem from './LogicItem__';
+/**
+ * 调用逻辑
+ */
+export declare class CallLogic extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'CallLogic' | 'CallConnector';
+    /**
+     * 唯一标识
+     */
+    uuid: string;
+    /**
+     * calleeNamespace
+     */
+    calleeNamespace: string;
+    /**
+     * calleeName
+     */
+    calleeName: string;
+    /**
+     * shortcut
+     */
+    shortcut: boolean;
+    /**
+     * handleError
+     */
+    handleError: boolean;
+    /**
+     * 类型参数
+     */
+    typeArguments?: Array<TypeAnnotation>;
+    /**
+     * 实际参数
+     */
+    arguments: Array<Argument>;
+    /**
+     * 验证规则
+     */
+    validation: BindAttribute;
+    /**
+     * 是否被折叠
+     */
+    isAdvancedSettingFolded: boolean;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<CallLogic>);
+    static from(source: any, parentNode?: any, parentKey?: string): CallLogic;
+    /**
+     * 设置验证规则
+     */
+    setValidation(validation: BindAttribute): void;
+    /**
+     * 设置是否被折叠
+     */
+    setIsAdvancedSettingFolded(isAdvancedSettingFolded: boolean): void;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+    /**
+     * 插入实际参数
+     * @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 typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+    /**
+     * 删除实际参数
+     * @param argument 已有的实际参数实例
+     */
+    removeArgument(argument: Argument): void;
+    get tsCalleeNamespace(): string;
+    get calleewholeKey(): string;
+    get calleeKey(): string;
+    /**
+     * 设置argment 触发别的地方的更新
+     */
+    setArgumentName({ argument }: {
+        argument: Argument[];
+    }): void;
+    /**
+     * 设置setCalleeName
+     */
+    setCalleeName(calleeName: string): void;
+    /**
+     * 设置calleeNamespace
+     */
+    setCalleeNamespace(calleeNamespace: string): void;
+    /**
+     * 设置 handleError
+     */
+    setHandleError(handleError: boolean): void;
+    _setCallee(logic: Logic): void;
+    setCallee(logic: Logic, argument?: Argument): void;
+    addCalleeArg(logic: Logic): void;
+    deleteCalleeArg(argIndex: number): void;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    get isViewLogic(): boolean;
+    get isComponentLogic(): boolean;
+    toJS(state?: TranslatorState): string;
+    toBrief(): string;
+    get useValidation(): boolean;
+    get useIife(): boolean;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    getCallNode(): Logic | undefined;
+    /** 获取类型标注时的偏移量 */
+    getQuickInfoOffset(range: Range, getCode: GetCode): {
+        line: number;
+        offset: number;
+    };
+    /**
+     * 是否允许验证规则
+     *  - 当前元素在前端，但是调用的函数在后端
+     */
+    enableValidation(): boolean;
+    get completeArguments(): Argument[];
+    static isSystem(node: CallLogic): boolean;
+    static getDefaultOptions(): {};
+}
+export default CallLogic;

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

@@ -0,0 +1,383 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type QueryJoinExpression from './QueryJoinExpression__';
+import type Entity from './Entity__';
+import type Structure from './Structure__';
+import type StructureProperty from './StructureProperty__';
+import type CompletionProperty from './CompletionProperty__';
+import type Identifier from './Identifier__';
+import type MemberExpression from './MemberExpression__';
+import TypeAnnotation from './TypeAnnotation__';
+import QuerySelectExpression from './QuerySelectExpression__';
+import QueryFromExpression from './QueryFromExpression__';
+import LogicItem from './LogicItem__';
+import QueryGroupByExpression from './QueryGroupByExpression__';
+import QueryOrderByExpression from './QueryOrderByExpression__';
+import QueryLimitExpression from './QueryLimitExpression__';
+/**
+ * 数据查询
+ */
+export declare class CallQueryComponent extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'CallQueryComponent';
+    /**
+     * 类型
+     */
+    typeAnnotation: TypeAnnotation;
+    /**
+     * select
+     */
+    select: QuerySelectExpression;
+    /**
+     * from
+     */
+    from: QueryFromExpression;
+    /**
+     * where
+     */
+    where: LogicItem;
+    /**
+     * where 草稿态
+     */
+    wherePlayground: Array<LogicItem>;
+    /**
+     * groupBy
+     */
+    groupBy: Array<QueryGroupByExpression>;
+    /**
+     * having
+     */
+    having: LogicItem;
+    /**
+     * having 草稿态
+     */
+    havingPlayground: Array<LogicItem>;
+    /**
+     * orderBy
+     */
+    orderBy: Array<QueryOrderByExpression>;
+    /**
+     * limit
+     */
+    limit: QueryLimitExpression;
+    /**
+     * 查询组件的局部版本
+     */
+    ideVersion: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<CallQueryComponent>);
+    static from(source: any, parentNode?: any, parentKey?: string): CallQueryComponent;
+    /**
+     * 设置select
+     */
+    setSelect(select: QuerySelectExpression): void;
+    /**
+     * 设置from
+     */
+    setFrom(from: QueryFromExpression): void;
+    /**
+     * 设置where
+     */
+    setWhere(where: LogicItem): void;
+    /**
+     * 设置groupBy
+     */
+    setGroupBy(groupBy: Array<QueryGroupByExpression>): void;
+    /**
+     * 设置having
+     */
+    setHaving(having: LogicItem): void;
+    /**
+     * 设置orderBy
+     */
+    setOrderBy(orderBy: Array<QueryOrderByExpression>): void;
+    /**
+     * 设置limit
+     */
+    setLimit(limit: QueryLimitExpression): void;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemInWherePlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemInWherePlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInWherePlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInWherePlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInWherePlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInWherePlayground(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInWherePlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInWherePlayground(logicItem: LogicItem): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
+    /**
+     * 插入查询分组
+     * @internal
+     * @param queryGroupByExpressionOptions 查询分组参数
+     */
+    _insertQueryGroupByExpressionAt(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>, index: number): QueryGroupByExpression;
+    /**
+     * 插入查询分组
+     * @internal
+     * @param queryGroupByExpression 已有的查询分组实例
+     */
+    _insertQueryGroupByExpressionAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
+    /**
+     * 插入查询分组
+     * @param queryGroupByExpressionOptions 查询分组参数
+     */
+    insertQueryGroupByExpressionAt(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>, index: number): QueryGroupByExpression;
+    /**
+     * 插入查询分组
+     * @param queryGroupByExpression 已有的查询分组实例
+     */
+    insertQueryGroupByExpressionAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
+    /**
+     * 添加查询分组
+     * @internal
+     * @param queryGroupByExpressionOptions 查询分组参数
+     */
+    _addQueryGroupByExpression(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>): QueryGroupByExpression;
+    /**
+     * 添加查询分组
+     * @internal
+     * @param queryGroupByExpression 已有的查询分组实例
+     */
+    _addQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
+    /**
+     * 添加查询分组
+     * @param queryGroupByExpressionOptions 查询分组参数
+     */
+    addQueryGroupByExpression(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>): QueryGroupByExpression;
+    /**
+     * 添加查询分组
+     * @param queryGroupByExpression 已有的查询分组实例
+     */
+    addQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
+    /**
+     * 插入查询排序子句
+     * @internal
+     * @param queryOrderByExpressionOptions 查询排序子句参数
+     */
+    _insertQueryOrderByExpressionAt(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>, index: number): QueryOrderByExpression;
+    /**
+     * 插入查询排序子句
+     * @internal
+     * @param queryOrderByExpression 已有的查询排序子句实例
+     */
+    _insertQueryOrderByExpressionAt(queryOrderByExpression: QueryOrderByExpression, index: number): QueryOrderByExpression;
+    /**
+     * 插入查询排序子句
+     * @param queryOrderByExpressionOptions 查询排序子句参数
+     */
+    insertQueryOrderByExpressionAt(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>, index: number): QueryOrderByExpression;
+    /**
+     * 插入查询排序子句
+     * @param queryOrderByExpression 已有的查询排序子句实例
+     */
+    insertQueryOrderByExpressionAt(queryOrderByExpression: QueryOrderByExpression, index: number): QueryOrderByExpression;
+    /**
+     * 添加查询排序子句
+     * @internal
+     * @param queryOrderByExpressionOptions 查询排序子句参数
+     */
+    _addQueryOrderByExpression(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>): QueryOrderByExpression;
+    /**
+     * 添加查询排序子句
+     * @internal
+     * @param queryOrderByExpression 已有的查询排序子句实例
+     */
+    _addQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
+    /**
+     * 添加查询排序子句
+     * @param queryOrderByExpressionOptions 查询排序子句参数
+     */
+    addQueryOrderByExpression(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>): QueryOrderByExpression;
+    /**
+     * 添加查询排序子句
+     * @param queryOrderByExpression 已有的查询排序子句实例
+     */
+    addQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInWherePlayground(logicItem: LogicItem): void;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInHavingPlayground(logicItem: LogicItem): void;
+    /**
+     * 删除查询分组
+     * @param queryGroupByExpression 已有的查询分组实例
+     */
+    removeQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): void;
+    /**
+     * 删除查询排序子句
+     * @param queryOrderByExpression 已有的查询排序子句实例
+     */
+    removeQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): void;
+    /**
+     * 获取添加时的默认选项
+     * @returns
+     */
+    static getDefaultOptions(): any;
+    toEmbeddedTSOfSubPart<T extends {
+        toEmbeddedTS: (state?: TranslatorState) => TranslatorGenerator;
+    }>(key: string, list: Array<T>, options: {
+        code: string;
+        state: TranslatorState;
+        multipleErrorType?: '__WHERE_MULTIPLE_CONDITION__' | '__HAVING_MULTIPLE_CONDITION__';
+    }): Generator<any, string, any>;
+    entityNames(): string[];
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(): string;
+    isAutoInfer(): boolean;
+    get entityPropertySelectable(): boolean;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    genPropertiesFrom(node: QueryFromExpression | QueryJoinExpression, properties?: StructureProperty[]): StructureProperty[];
+    genPropertyListOfFrom(node: QueryFromExpression | QueryJoinExpression, entities?: any[]): any[];
+    genPropertyListOfAggregate(node: CallQueryComponent, entities: Entity[]): {
+        concept: string;
+        name: string;
+        typeAnnotation: {
+            concept: string;
+            typeKind: string;
+            typeNamespace: string;
+            typeName: string;
+        };
+    }[];
+    genPropertyListOfGroupBy(node: CallQueryComponent, entities: Entity[]): {
+        concept: string;
+        name: string;
+        typeAnnotation: {
+            concept: "TypeAnnotation";
+            typeKind: "function" | "primitive" | "reference" | "generic" | "typeParam" | "union" | "anonymousStructure";
+            typeName: string;
+            typeNamespace: string;
+        };
+    }[];
+    genStructure(structureName?: string, properties?: any[]): Structure;
+    saveStructure(): void;
+    saveStructureNoInfer(entities?: any[]): void;
+    removeStructure(structureName?: string): void;
+    getEntityInfos(node: QueryFromExpression | QueryJoinExpression, set?: Set<unknown>): unknown[];
+    get entityInfos(): unknown[];
+    getCompletionPropertyOfEntities(): {
+        name: string;
+        icon: string;
+        children: {
+            concept: string;
+            name: string;
+            children: CompletionProperty[];
+        }[];
+    };
+    getCompletionPropertyOfAggregateAsNames(): {
+        name: string;
+        icon: string;
+        children: CompletionProperty[];
+        expanded: boolean;
+    };
+    getCompletionPropertyOfGroupByAsNames(): {
+        name: string;
+        icon: string;
+        children: CompletionProperty[];
+        expanded: boolean;
+    };
+    /**
+     * 获取当前内部使用到的变量
+     */
+    getContentVariable(): (Identifier | MemberExpression)[];
+    initFieldSelectElement(node?: CallQueryComponent): void;
+    inFromJoinPart(entityName: string): boolean;
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default CallQueryComponent;