@lcap/nasl 0.3.9 → 0.3.10-beta

package/out/types/logic/Debugger.d.ts

@@ -0,0 +1,156 @@
+import { App, Logic, BreakPoint, EventEmitter, LogicItem } from '..';
+interface ScopeValue {
+    name: string;
+    result: {
+        type: string;
+        value: unknown;
+    };
+}
+interface cf {
+    componentId: string;
+    callFrameId: number;
+    line: number;
+    invokeLocation: {
+        line: number;
+        componentId: string;
+    };
+}
+interface sourceMapFrontObj {
+    isLogic: boolean;
+    node: LogicItem;
+    from: number;
+    to: number;
+}
+interface CallFrame {
+    target: {
+        node: LogicItem | Logic | sourceMapFrontObj;
+    };
+    invokeItem: LogicItem;
+    callFrameId: number;
+    className: string;
+    lineNumber: number;
+}
+declare class SocketEvent extends EventEmitter {
+    app: App;
+    debuggerClient: any;
+    emitSocket(payload: any): void;
+}
+interface FrontEndResponsePayload {
+    code: number;
+    data: {
+        result: {
+            value: unknown;
+        };
+        sourceCodeId: string;
+        id: string;
+        breakpointId: string;
+        requestId: string;
+        callFramesResolved: Array<cf>;
+        location: {
+            componentId: string;
+            line: number;
+        };
+    };
+}
+interface BackendResponseData {
+    status: string;
+    name: string;
+    threadId: string;
+    requestId: string;
+    className: string;
+    lineNumber: number;
+    stackFrames: {
+        className: string;
+        lineNumber: number;
+    }[];
+    variables: {
+        [key: string]: unknown;
+    };
+}
+interface Thread {
+    id: string;
+    requestId: string;
+    frontendStack: Array<Partial<cf>>;
+    callFrameId: number;
+    breakPoint: BreakPoint;
+    evaluateValue: {
+        [id: string]: unknown;
+    };
+    callFrames: Array<Partial<CallFrame>>;
+    callFrameScope: Array<{
+        variables: Array<ScopeValue>;
+        params: Array<ScopeValue>;
+        returns: Array<ScopeValue>;
+    }>;
+    evaluateExpression: string;
+}
+export declare class Debugger extends EventEmitter {
+    app: App;
+    debuggerClient: any;
+    currentThread: Partial<Thread>;
+    threads: Array<Partial<Thread>>;
+    currentFrontEndThread: Thread;
+    socketEventEmitter: SocketEvent;
+    frontendConnection: boolean;
+    backendConnection: boolean;
+    ideConnection: boolean;
+    breakPoints: Array<BreakPoint>;
+    temporaryBreakPoint: BreakPoint;
+    private temporaryBreakPointTriggered;
+    logicIdClassMap: {
+        [id: string]: string;
+    };
+    classLogicIdMap: {
+        [id: string]: string;
+    };
+    booting: boolean;
+    temporaryLogicCallStack: {
+        callFramesResolved: Array<Partial<cf>>;
+    };
+    get isConnected(): boolean;
+    get isBreak(): BreakPoint;
+    get isInFrontendThread(): boolean;
+    constructor();
+    closeConnect(): Promise<void>;
+    boot(): Promise<void>;
+    resetState(): void;
+    onFetchBreakPoint(data: Partial<FrontEndResponsePayload>): Promise<void>;
+    onBreakPointSettle(data: Partial<FrontEndResponsePayload>): void;
+    onRemoveBreakpointsettle(data: FrontEndResponsePayload): void;
+    onConnection(data: Partial<FrontEndResponsePayload> | Partial<BackendResponseData>, source: string): Promise<void>;
+    onFrontEndConnection(data: Partial<FrontEndResponsePayload>): void;
+    onBackEndConnection(data: Partial<BackendResponseData>): Promise<void>;
+    loadBackEndSourceMap(): Promise<void>;
+    onConnectionEnd(): void;
+    onLogicTrace(data: Partial<FrontEndResponsePayload>): void;
+    onLogicTraceEnd(): void;
+    onPaused(data: Partial<FrontEndResponsePayload> | Partial<BackendResponseData>, source: string): void;
+    onFrontEndPaused({ code, data }: Partial<FrontEndResponsePayload>): void;
+    resolveBackEndTarget(className: string, lineNumber: number): Promise<{
+        node: LogicItem;
+        classIdentify?: string;
+        from?: number;
+        lineFrom?: number;
+        end?: number;
+        vertexId?: string;
+        logicId?: string;
+    }>;
+    onBackEndPaused(data: Partial<BackendResponseData>): Promise<void>;
+    onBackEndException(data: BackendResponseData): void;
+    onEvaluateResult({ code, data }: FrontEndResponsePayload): void;
+    evaluateExpression(expression: string): void;
+    setRemoteBreakPoint(bp: BreakPoint): Promise<void>;
+    removeAllBreakPoint(): Promise<void>;
+    enableAllBreakPoint(): Promise<void>;
+    disableAllBreakPoint(): Promise<void>;
+    removeRemoteBreakPoint(bp: BreakPoint): Promise<void>;
+    removeRemoteBreakPointRoundTrip(bp: BreakPoint): Promise<void>;
+    setRemoteBreakPointRoundTrip(bp: BreakPoint): Promise<BreakPoint>;
+    step(): Promise<void>;
+    stepInto(): Promise<void>;
+    stepOut(): Promise<void>;
+    resetTemporaryBreakPoint(): void;
+    resumeUserAction(): void;
+    resume(): void;
+}
+export {};