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

package/dist/src/natural/genNaturalTS.d.ts

@@ -0,0 +1,241 @@
+import { App, View, Logic, BaseNode, Frontend } from '../concepts';
+export declare function genNaturalTS(app: App, currentNode?: BaseNode, focusedNodePath?: string): string;
+export declare const genTsBlock: (code: string) => string;
+export declare const getLogicStructures: (logic: Logic, type: string, desc: {
+    description: string;
+    codeStr: string;
+}, namespace: string) => string;
+export declare const getNaslCore: (logicType: string) => {
+    code: string;
+    naslCore: string;
+};
+export declare const getNaslUtil: () => {
+    code: string;
+    naslUtil: string;
+};
+export declare const getNaslUi: () => {
+    code: string;
+    naslUI: string;
+};
+export declare const getNaslOql: () => {
+    code: string;
+    naslOql: string;
+};
+export declare const getEnums: (app: App, state: any, moduleIndexList?: string[]) => {
+    code: string;
+    namespace: string;
+    enums: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+};
+export declare const getEntities: (app: App, state: any, moduleIndexList?: string[]) => {
+    code: string;
+    entities: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    }[];
+};
+export declare const getStructures: (app: App, state: any, moduleIndexList?: string[]) => {
+    code: string;
+    structures: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+};
+export declare const getLogics: (app: App, currentNode: BaseNode, moduleIndexList?: string[]) => {
+    code: string;
+    appLogics: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+};
+export declare const getModuleInterfaces: (app: App, state: any, moduleIndexList?: string[]) => {
+    code: string;
+    interfaceDependencies: {
+        name: string;
+        structures: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+        logics: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+    }[];
+};
+export declare const getConnectors: (app: App, state: any, moduleIndexList?: string[]) => {
+    code: string;
+    connections: {
+        name: string;
+        structures: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+        logics: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+    }[];
+};
+export declare const getDependencies: (app: App, state: any, moduleIndexList?: string[]) => {
+    code: string;
+    dependencies: {
+        name: string;
+        structures: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+        logics: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+    }[];
+};
+export declare const getFrontendVariables: (frontend: Frontend, state: any) => {
+    code: string;
+    frontendVar: string;
+};
+export declare const getChildrenViews: (view: View, currentNode: BaseNode, convertChildren: boolean, prefix: string) => {
+    description: string;
+    code: string;
+}[];
+export declare const getFrontendViews: (frontend: Frontend, state: any, currentNode: BaseNode, convertChildren: boolean) => {
+    code: string;
+    views: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+};
+export declare const getCurrentNodeContext: (currentNode: BaseNode, focusedNodePath?: string) => {
+    code: string;
+    currentLogic: string;
+};
+export declare function genNaturalTSContext(app: App, currentNode?: BaseNode, focusedNodePath?: string, moduleIndexList?: string[]): string;
+export declare const genNaturalTsContextJson: (app: App, currentNode?: BaseNode, focusedNodePath?: string) => {
+    naslCore: string;
+    naslUtil: string;
+    naslUI: string;
+    naslOql: string;
+    enums: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+    entities: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    }[];
+    structures: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+    appLogics: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+    interfaceDependencies: {
+        name: string;
+        structures: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+        logics: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+    }[];
+    connections: {
+        name: string;
+        structures: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+        logics: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+    }[];
+    dependencies: {
+        name: string;
+        structures: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+        logics: {
+            namespace: string;
+            data: {
+                description: string;
+                code: string;
+            }[];
+        };
+    }[];
+    frontendVar: string;
+    views: {
+        namespace: string;
+        data: {
+            description: string;
+            code: string;
+        }[];
+    };
+    currentLogic: string;
+};

package/dist/src/natural/index.d.ts

@@ -0,0 +1,6 @@
+export * from './genNaturalTS';
+export * from './transformTSCode';
+export * from './prompt/executeClaims';
+export * from './prompt/analyzeClaims';
+export * from './prompt/analyzeFormatOutput';
+export * from './prompt/analyzeTasks';

package/dist/src/natural/naslStdlibMap.d.ts

@@ -0,0 +1 @@
+export declare const getNaslStbMap: (key?: string) => any;

package/dist/src/natural/prompt/analyzeClaims.d.ts

@@ -0,0 +1 @@
+export declare const analyzeClaims: (params: any) => any;

package/dist/src/natural/prompt/analyzeFormatOutput.d.ts

@@ -0,0 +1 @@
+export declare const analyzeFormatOutput: () => string;

package/dist/src/natural/prompt/analyzeTasks.d.ts

@@ -0,0 +1 @@
+export declare const analyzeTasks: () => string;

package/dist/src/natural/prompt/executeClaims.d.ts

@@ -0,0 +1 @@
+export declare const executeClaims: (params: any) => any;

package/dist/src/natural/transformTSCode.d.ts

@@ -0,0 +1,7 @@
+import * as babel from '@babel/core';
+import * as naslTypes from '../concepts';
+export declare function tryParseTS(tsCode: string): babel.types.File;
+export declare function transformTSCode(tsCode: string, contextLogicName: string, type?: string): naslTypes.Logic;
+export declare function tryTransformTSCode(tsCode: string, contextLogicName: string, type?: string): naslTypes.Logic;
+export declare function transformTSCodeEx(answer: any, activeLogic: any, context: any): void;
+export declare function transformTSCodeToExpression(answer: any, context: any): naslTypes.LogicItem[];

package/dist/src/sentry/index.d.ts

@@ -0,0 +1,34 @@
+export declare const CONSTRUCTOR_HOOK = "constructor";
+export declare const BEFORE_HOOK = "before";
+export declare const AFTER_HOOK = "after";
+export declare const NASL_NODE = "nasl-node";
+export declare const NASL_SERVER = "nasl-server";
+export declare const TS_WORKER_MESSAGER = "ts-worker-messager";
+export declare const getAxios: () => import("axios").AxiosStatic;
+declare type ClassType = {
+    new (...args: any[]): any;
+};
+declare type FunctionType = (...args: any[]) => any;
+declare type Source = {
+    instance: any;
+    hook: string;
+    name: string;
+    params: any[];
+    result?: any;
+};
+declare type Listener = (source: Source) => FunctionType | void;
+declare type Monitor = (key: string) => <T extends ClassType>(SourceClass: T) => T;
+export declare const removeListener: (key: string) => (listener: Listener) => void;
+export declare const addListener: (key: string) => (listener: Listener, capture?: boolean) => () => void;
+export declare const sentryMonitor: Monitor;
+export declare const extendSentryMonitor: Monitor;
+export declare const addListenerToNaslNode: (listener: Listener, capture?: boolean) => () => void;
+export declare const addListenerToNaslServer: (listener: Listener, capture?: boolean) => () => void;
+export declare const addListenerToTSWorkerMessager: (listener: Listener, capture?: boolean) => () => void;
+export declare const sentryMonitorNaslNode: <T extends ClassType>(SourceClass: T) => T;
+export declare const sentryMonitorNaslServer: <T extends ClassType>(SourceClass: T) => T;
+export declare const sentryMonitorTSWorkerMessager: <T extends ClassType>(SourceClass: T) => T;
+export declare const extendSentryMonitorNaslNode: <T extends ClassType>(SourceClass: T) => T;
+export declare const extendSentryMonitorNaslServer: <T extends ClassType>(SourceClass: T) => T;
+export declare const extendSentryMonitorTSWorkerMessager: <T extends ClassType>(SourceClass: T) => T;
+export {};

package/dist/src/server/createUiTs.d.ts

@@ -0,0 +1,17 @@
+import { Logic } from '..';
+export declare const elementsEventsMap: {
+    [componentTagEventName: string]: any;
+};
+export declare function getAllComponentEventMap(allComponent: any): {
+    [componentTagEventName: string]: any;
+};
+export default function formatUiTs(allComponent: any): {
+    code: string;
+    elementsLogic: {
+        [componentName: string]: Logic[];
+    };
+    elementsEventsMap: {
+        [componentTagEventName: string]: any;
+    };
+};
+export declare function createEleLogins(components: Record<string, any>): Record<string, any>;

package/dist/src/server/entity2LogicNamespace.d.ts

@@ -0,0 +1,10 @@
+import { Namespace, Entity, Logic } from '..';
+export declare function entity2LogicNamespace(entity: Entity): Namespace;
+interface entityTreeFragment {
+    logics: Array<Logic>;
+    name: string;
+    id: string;
+    concept: string;
+}
+export declare function entityToTreeFragment(entity: Entity): entityTreeFragment;
+export {};

package/dist/src/server/event.d.ts

@@ -0,0 +1,30 @@
+export const trigger: ({
+    name: string;
+    title: string;
+    description: string;
+    params: {
+        name: string;
+        type: string;
+        description: string;
+        schema: {
+            $ref: string;
+        };
+    }[];
+} | {
+    name: string;
+    title: string;
+    params: {
+        name: string;
+        type: string;
+        description: string;
+        schema: {
+            $ref: string;
+        };
+    }[];
+    description?: undefined;
+} | {
+    name: string;
+    title: string;
+    description?: undefined;
+    params?: undefined;
+})[];

package/dist/src/server/extendBaseNode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/server/formatTsUtils.d.ts

@@ -0,0 +1,36 @@
+import { Identifier, TypeAnnotation, MemberExpression, CompletionProperty, Variable, ConfigProperty, types, BackendVariable } from '..';
+interface variableItem {
+    text: string;
+    completionDetail: any;
+    children?: variableItem[] | any;
+    name?: string;
+    value?: string;
+    expression: MemberExpression | Identifier;
+}
+/**
+ * 解析 Completion 和 QuickInfo 的 displayString
+ * 生成 TypeAnnotation
+ * @param displayString
+ */
+export declare function type2TypeAnnotation(oldType: Array<any> | {}): Generator<any, TypeAnnotation, any>;
+/**
+ * 解析 Completion 和 QuickInfo 的 displayString
+ * 生成 TypeAnnotation
+ * @param displayString
+ * @returns TypeAnnotation
+ */
+export declare function displayString2TypeAnnotation(typeStr: string, parentPrefix?: string): TypeAnnotation;
+export declare function getPlatformType(type: string, node?: types.SyntaxNode): string;
+export declare function isNoChildType(type: String): boolean;
+/**
+ * 获取下一级的节点进行递归
+ * @param typeKey 当前节点的类型，主要为了取出内部的 T中的实际类型
+ * @param item 当前节点的内容
+ * @param node 获取变量框的位置
+ */
+export declare function nextFindTypeChild(typeKey: string, item: any, node: types.SyntaxNode): void;
+export declare function formatVariableData(data: unknown | variableItem[], node: types.SyntaxNode, parent?: any): CompletionProperty[];
+export declare function formatBackendVariables(variables: Array<BackendVariable>): CompletionProperty[];
+export declare function formatFrontEndVariables(frontEndVariables: Array<Variable>): CompletionProperty[];
+export declare function formatConfigProperties(configProperties: Array<ConfigProperty>, isView: Boolean): any;
+export {};

package/dist/src/server/getConnector.d.ts

@@ -0,0 +1,15 @@
+import type CallConnector from '../concepts/CallConnector__';
+import type { App } from '..';
+import type Connector from '../concepts/Connector__';
+import type Connection from '../concepts/Connection__';
+export declare function getConnections(node: CallConnector): Connection[];
+export declare function getConnectorTree(node: CallConnector, filterText: string): {
+    name: string;
+    title: string;
+    icon: string;
+    expanded: boolean;
+    unselectable: boolean;
+    isCustom: boolean;
+    children: Connection[];
+}[];
+export declare function publishConnector(app: App, connector: Connector): void;

package/dist/src/server/getExtensionModules.d.ts

@@ -0,0 +1,3 @@
+import { App, Module, Namespace, OverriddenLogic, Connector } from '..';
+export declare function getExtensionModules(app: App): Module[];
+export declare function moduleToLogicNamesapce(m: Module | Connector, overriddenLogics: Array<OverriddenLogic>): Namespace;

package/dist/src/server/getFunctions.d.ts

@@ -0,0 +1,3 @@
+export declare function getFunctions(): import("..").Namespace;
+export declare function getBuildInFunction(name: string): import("..").Function;
+export declare function getValidationInFunction(name: string): import("..").Function;

package/dist/src/server/getInterfaces.d.ts

@@ -0,0 +1,2 @@
+import { CallInterface, BindEvent } from '..';
+export declare function getInterfaces(node: CallInterface | BindEvent, filterText?: string): {};

package/dist/src/server/getLogging.d.ts

@@ -0,0 +1 @@
+export declare function getLogging(): import("..").Namespace;

package/dist/src/server/getLogics.d.ts

@@ -0,0 +1,5 @@
+import { Identifier } from '../concepts/Identifier__';
+import { CallLogic, BindEvent, Namespace, Logic } from '..';
+export declare function getLogics(node: CallLogic | BindEvent | Identifier | Logic, needAllLogic?: boolean): Promise<Namespace[]>;
+export declare function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic, needAllLogic?: boolean): Namespace[];
+export declare function iteratorTree(treeList: {}[], filterText?: string): {}[];

package/dist/src/server/getMemberIdentifier.d.ts

@@ -0,0 +1,17 @@
+import { BaseNode, CompletionProperty, Identifier, Enum, types } from '..';
+export declare function formatEnums(enums: Array<Enum>): CompletionProperty[];
+export declare function getMemberIdentifier(node: types.SyntaxNode): Promise<{
+    name: string;
+    children: CompletionProperty[];
+    expanded: boolean;
+    icon: string;
+}[]>;
+export declare function getFrontEndVariablesIdentifier(node: BaseNode): CompletionProperty[];
+export declare function getLiteralsIdentifier(): CompletionProperty[];
+export declare function getEnumsIdentifier(node: BaseNode): CompletionProperty[];
+export declare function getBackendVariablesIdentifier(node: BaseNode): CompletionProperty[];
+export declare function getVariableIdentifier(node: types.SyntaxNode): Promise<CompletionProperty[]>;
+export declare function getGlobalVariableIdentifier(node: BaseNode): Promise<CompletionProperty[]>;
+export declare function getSelectNextCompletionData(node: Identifier, completionProperty?: CompletionProperty): Promise<CompletionProperty[]>;
+export declare function getConfigsIdentifier(node: BaseNode): CompletionProperty[];
+export declare function getPageComponentsIdentifier(node: types.SyntaxNode): CompletionProperty[];

package/dist/src/server/getProcessComponents.d.ts

@@ -0,0 +1,2 @@
+export declare function getProcessComponents(): import("..").Namespace;
+export declare function getProcessComponent(name: string): import("..").ProcessComponent;

package/dist/src/server/getProcesses.d.ts

@@ -0,0 +1,33 @@
+import Constant from '../concepts/Constant__';
+import { CompletionProperty, Process, ProcessElement, Namespace, Logic, Return, Variable, StructureProperty, Param, MemberExpression, LogicItem, EntityProperty } from '..';
+export declare function genLaunchProcess(process: Process): Logic;
+export declare function process2LogicNamespace(process: Process): Namespace;
+export declare function returnToParam(r: Return): Param;
+export declare function constantToParam(v: Constant): Param;
+export declare function genUserTaskLogic(userTask: ProcessElement): Logic[];
+export declare function userTask2LogicNamespace(userTask: ProcessElement): Namespace;
+declare type CompletionData = {
+    name: string;
+    concept: string;
+    value: string;
+    selectable?: boolean;
+    children: Array<CompletionData>;
+};
+declare type Suggestion = {
+    name: string;
+    children: Array<CompletionProperty | CompletionData>;
+};
+declare type VariableSuggestion = Array<Suggestion>;
+export declare function travelDown(node: any, callback: (node: any) => void): void;
+export declare function syncMemberExpression(elem: ProcessElement | Process, callback: (node: MemberExpression) => void): void;
+export declare function genMemberExpression(path: string): MemberExpression;
+export declare function genCompletionProperty(prefix?: string[]): (v: Variable | Param | Return | Constant | EntityProperty | StructureProperty) => CompletionProperty;
+export declare function getPreviousTask(node: ProcessElement, nodePorcess?: Process): ProcessElement[];
+export declare function getProcessVariableSuggestions(node: LogicItem, abandonConstant?: boolean): CompletionProperty;
+export declare function getProcessVaraibleSelections(node: Logic, list: VariableSuggestion): void;
+export declare function getProcessVariableSuggestionsAll(node: ProcessElement, exitConstantId?: Boolean): CompletionProperty;
+export declare function getFlowAfterElements(el: ProcessElement): ProcessElement[];
+export declare function getFlowBeforeElements(el: ProcessElement): ProcessElement[];
+export declare function isFromStartNode(el: ProcessElement): boolean;
+export declare function findNodeAfterNodeInFlow(el: ProcessElement): unknown[];
+export {};

package/dist/src/server/getScope.d.ts

@@ -0,0 +1,13 @@
+import { Logic, View, Process } from '..';
+declare type wordScope = {
+    Param?: string[];
+    Return?: string[];
+    Variable?: string[];
+    Constant?: string[];
+    Logic?: string[];
+};
+export declare function getLogicScopeWords(logic: Logic): wordScope;
+export declare function getViewScopeWords(view: View): wordScope;
+export declare function getProcessScopeWords(process: Process): wordScope;
+export declare function combineScope(a: wordScope, b: wordScope): wordScope;
+export {};

package/dist/src/server/getValidates.d.ts

@@ -0,0 +1,3 @@
+import type { CallFunction } from '..';
+export declare function getValidates(node?: CallFunction): import("..").Namespace;
+export declare function getValidateFunction(name: string): import("..").Function;

package/dist/src/server/index.d.ts

@@ -0,0 +1,5 @@
+import { NaslServer as NaslServerClass } from './naslServer';
+import './extendBaseNode';
+declare const server: any;
+export default server;
+export declare const NaslServer: typeof NaslServerClass;