vscode-debugadapter

vscode-debugadapter

Version 1.51.0
Published 3 years ago
257 kB
2 dependencies
MIT license

Install

npm i vscode-debugadapter

yarn add vscode-debugadapter

pnpm add vscode-debugadapter

Overview

Debug adapter implementation for node

Index

Variables

variable logger

const logger: Logger.Logger;

Classes

class Breakpoint

class Breakpoint implements DebugProtocol.Breakpoint {}

constructor

constructor(verified: boolean, line?: number, column?: number, source?: Source);

property verified

verified: boolean;

method setId

setId: (id: number) => void;

class BreakpointEvent

class BreakpointEvent extends Event implements DebugProtocol.BreakpointEvent {}

constructor

constructor(reason: string, breakpoint: DebugProtocol.Breakpoint);

property body

body: { reason: string; breakpoint: DebugProtocol.Breakpoint };

class CapabilitiesEvent

class CapabilitiesEvent extends Event implements DebugProtocol.CapabilitiesEvent {}

constructor

constructor(capabilities: DebugProtocol.Capabilities);

property body

body: { capabilities: DebugProtocol.Capabilities };

class CompletionItem

class CompletionItem implements DebugProtocol.CompletionItem {}

constructor

constructor(label: string, start: number, length?: number);

property label

label: string;

property length

length: number;

property start

start: number;

class ContinuedEvent

class ContinuedEvent extends Event implements DebugProtocol.ContinuedEvent {}

constructor

constructor(threadId: number, allThreadsContinued?: boolean);

property body

body: { threadId: number };

class DebugSession

class DebugSession extends ProtocolServer {}

constructor

constructor(
    obsolete_debuggerLinesAndColumnsStartAt1?: boolean,
    obsolete_isServer?: boolean
);

method attachRequest

protected attachRequest: (
    response: DebugProtocol.AttachResponse,
    args: DebugProtocol.AttachRequestArguments,
    request?: DebugProtocol.Request
) => void;

method breakpointLocationsRequest

protected breakpointLocationsRequest: (
    response: DebugProtocol.BreakpointLocationsResponse,
    args: DebugProtocol.BreakpointLocationsArguments,
    request?: DebugProtocol.Request
) => void;

method cancelRequest

protected cancelRequest: (
    response: DebugProtocol.CancelResponse,
    args: DebugProtocol.CancelArguments,
    request?: DebugProtocol.Request
) => void;

method completionsRequest

protected completionsRequest: (
    response: DebugProtocol.CompletionsResponse,
    args: DebugProtocol.CompletionsArguments,
    request?: DebugProtocol.Request
) => void;

method configurationDoneRequest

protected configurationDoneRequest: (
    response: DebugProtocol.ConfigurationDoneResponse,
    args: DebugProtocol.ConfigurationDoneArguments,
    request?: DebugProtocol.Request
) => void;

method continueRequest

protected continueRequest: (
    response: DebugProtocol.ContinueResponse,
    args: DebugProtocol.ContinueArguments,
    request?: DebugProtocol.Request
) => void;

method convertClientColumnToDebugger

protected convertClientColumnToDebugger: (column: number) => number;

method convertClientLineToDebugger

protected convertClientLineToDebugger: (line: number) => number;

method convertClientPathToDebugger

protected convertClientPathToDebugger: (clientPath: string) => string;

method convertDebuggerColumnToClient

protected convertDebuggerColumnToClient: (column: number) => number;

method convertDebuggerLineToClient

protected convertDebuggerLineToClient: (line: number) => number;

method convertDebuggerPathToClient

protected convertDebuggerPathToClient: (debuggerPath: string) => string;

method customRequest

protected customRequest: (
    command: string,
    response: DebugProtocol.Response,
    args: any,
    request?: DebugProtocol.Request
) => void;

Override this hook to implement custom requests.

method dataBreakpointInfoRequest

protected dataBreakpointInfoRequest: (
    response: DebugProtocol.DataBreakpointInfoResponse,
    args: DebugProtocol.DataBreakpointInfoArguments,
    request?: DebugProtocol.Request
) => void;

method disassembleRequest

protected disassembleRequest: (
    response: DebugProtocol.DisassembleResponse,
    args: DebugProtocol.DisassembleArguments,
    request?: DebugProtocol.Request
) => void;

method disconnectRequest

protected disconnectRequest: (
    response: DebugProtocol.DisconnectResponse,
    args: DebugProtocol.DisconnectArguments,
    request?: DebugProtocol.Request
) => void;

method dispatchRequest

protected dispatchRequest: (request: DebugProtocol.Request) => void;

method evaluateRequest

protected evaluateRequest: (
    response: DebugProtocol.EvaluateResponse,
    args: DebugProtocol.EvaluateArguments,
    request?: DebugProtocol.Request
) => void;

method exceptionInfoRequest

protected exceptionInfoRequest: (
    response: DebugProtocol.ExceptionInfoResponse,
    args: DebugProtocol.ExceptionInfoArguments,
    request?: DebugProtocol.Request
) => void;

method gotoRequest

protected gotoRequest: (
    response: DebugProtocol.GotoResponse,
    args: DebugProtocol.GotoArguments,
    request?: DebugProtocol.Request
) => void;

method gotoTargetsRequest

protected gotoTargetsRequest: (
    response: DebugProtocol.GotoTargetsResponse,
    args: DebugProtocol.GotoTargetsArguments,
    request?: DebugProtocol.Request
) => void;

method initializeRequest

protected initializeRequest: (
    response: DebugProtocol.InitializeResponse,
    args: DebugProtocol.InitializeRequestArguments
) => void;

method launchRequest

protected launchRequest: (
    response: DebugProtocol.LaunchResponse,
    args: DebugProtocol.LaunchRequestArguments,
    request?: DebugProtocol.Request
) => void;

method loadedSourcesRequest

protected loadedSourcesRequest: (
    response: DebugProtocol.LoadedSourcesResponse,
    args: DebugProtocol.LoadedSourcesArguments,
    request?: DebugProtocol.Request
) => void;

method nextRequest

protected nextRequest: (
    response: DebugProtocol.NextResponse,
    args: DebugProtocol.NextArguments,
    request?: DebugProtocol.Request
) => void;

method pauseRequest

protected pauseRequest: (
    response: DebugProtocol.PauseResponse,
    args: DebugProtocol.PauseArguments,
    request?: DebugProtocol.Request
) => void;

method readMemoryRequest

protected readMemoryRequest: (
    response: DebugProtocol.ReadMemoryResponse,
    args: DebugProtocol.ReadMemoryArguments,
    request?: DebugProtocol.Request
) => void;

method restartFrameRequest

protected restartFrameRequest: (
    response: DebugProtocol.RestartFrameResponse,
    args: DebugProtocol.RestartFrameArguments,
    request?: DebugProtocol.Request
) => void;

method restartRequest

protected restartRequest: (
    response: DebugProtocol.RestartResponse,
    args: DebugProtocol.RestartArguments,
    request?: DebugProtocol.Request
) => void;

method reverseContinueRequest

protected reverseContinueRequest: (
    response: DebugProtocol.ReverseContinueResponse,
    args: DebugProtocol.ReverseContinueArguments,
    request?: DebugProtocol.Request
) => void;

method run

static run: (debugSession: typeof DebugSession) => void;

A virtual constructor...

method runInTerminalRequest

runInTerminalRequest: (
    args: DebugProtocol.RunInTerminalRequestArguments,
    timeout: number,
    cb: (response: DebugProtocol.RunInTerminalResponse) => void
) => void;

method scopesRequest

protected scopesRequest: (
    response: DebugProtocol.ScopesResponse,
    args: DebugProtocol.ScopesArguments,
    request?: DebugProtocol.Request
) => void;

method sendErrorResponse

protected sendErrorResponse: (
    response: DebugProtocol.Response,
    codeOrMessage: number | DebugProtocol.Message,
    format?: string,
    variables?: any,
    dest?: ErrorDestination
) => void;

method setBreakPointsRequest

protected setBreakPointsRequest: (
    response: DebugProtocol.SetBreakpointsResponse,
    args: DebugProtocol.SetBreakpointsArguments,
    request?: DebugProtocol.Request
) => void;

method setDataBreakpointsRequest

protected setDataBreakpointsRequest: (
    response: DebugProtocol.SetDataBreakpointsResponse,
    args: DebugProtocol.SetDataBreakpointsArguments,
    request?: DebugProtocol.Request
) => void;

method setDebuggerColumnsStartAt1

setDebuggerColumnsStartAt1: (enable: boolean) => void;

method setDebuggerLinesStartAt1

setDebuggerLinesStartAt1: (enable: boolean) => void;

method setDebuggerPathFormat

setDebuggerPathFormat: (format: string) => void;

method setExceptionBreakPointsRequest

protected setExceptionBreakPointsRequest: (
    response: DebugProtocol.SetExceptionBreakpointsResponse,
    args: DebugProtocol.SetExceptionBreakpointsArguments,
    request?: DebugProtocol.Request
) => void;

method setExpressionRequest

protected setExpressionRequest: (
    response: DebugProtocol.SetExpressionResponse,
    args: DebugProtocol.SetExpressionArguments,
    request?: DebugProtocol.Request
) => void;

method setFunctionBreakPointsRequest

protected setFunctionBreakPointsRequest: (
    response: DebugProtocol.SetFunctionBreakpointsResponse,
    args: DebugProtocol.SetFunctionBreakpointsArguments,
    request?: DebugProtocol.Request
) => void;

method setInstructionBreakpointsRequest

protected setInstructionBreakpointsRequest: (
    response: DebugProtocol.SetInstructionBreakpointsResponse,
    args: DebugProtocol.SetInstructionBreakpointsArguments,
    request?: DebugProtocol.Request
) => void;

method setRunAsServer

setRunAsServer: (enable: boolean) => void;

method setVariableRequest

protected setVariableRequest: (
    response: DebugProtocol.SetVariableResponse,
    args: DebugProtocol.SetVariableArguments,
    request?: DebugProtocol.Request
) => void;

method shutdown

shutdown: () => void;

method sourceRequest

protected sourceRequest: (
    response: DebugProtocol.SourceResponse,
    args: DebugProtocol.SourceArguments,
    request?: DebugProtocol.Request
) => void;

method stackTraceRequest

protected stackTraceRequest: (
    response: DebugProtocol.StackTraceResponse,
    args: DebugProtocol.StackTraceArguments,
    request?: DebugProtocol.Request
) => void;

method stepBackRequest

protected stepBackRequest: (
    response: DebugProtocol.StepBackResponse,
    args: DebugProtocol.StepBackArguments,
    request?: DebugProtocol.Request
) => void;

method stepInRequest

protected stepInRequest: (
    response: DebugProtocol.StepInResponse,
    args: DebugProtocol.StepInArguments,
    request?: DebugProtocol.Request
) => void;

method stepInTargetsRequest

protected stepInTargetsRequest: (
    response: DebugProtocol.StepInTargetsResponse,
    args: DebugProtocol.StepInTargetsArguments,
    request?: DebugProtocol.Request
) => void;

method stepOutRequest

protected stepOutRequest: (
    response: DebugProtocol.StepOutResponse,
    args: DebugProtocol.StepOutArguments,
    request?: DebugProtocol.Request
) => void;

method terminateRequest

protected terminateRequest: (
    response: DebugProtocol.TerminateResponse,
    args: DebugProtocol.TerminateArguments,
    request?: DebugProtocol.Request
) => void;

method terminateThreadsRequest

protected terminateThreadsRequest: (
    response: DebugProtocol.TerminateThreadsResponse,
    args: DebugProtocol.TerminateThreadsArguments,
    request?: DebugProtocol.Request
) => void;

method threadsRequest

protected threadsRequest: (
    response: DebugProtocol.ThreadsResponse,
    request?: DebugProtocol.Request
) => void;

method variablesRequest

protected variablesRequest: (
    response: DebugProtocol.VariablesResponse,
    args: DebugProtocol.VariablesArguments,
    request?: DebugProtocol.Request
) => void;

method writeMemoryRequest

protected writeMemoryRequest: (
    response: DebugProtocol.WriteMemoryResponse,
    args: DebugProtocol.WriteMemoryArguments,
    request?: DebugProtocol.Request
) => void;

class Event

class Event extends Message implements DebugProtocol.Event {}

constructor

constructor(event: string, body?: any);

property event

event: string;

class ExitedEvent

class ExitedEvent extends Event implements DebugProtocol.ExitedEvent {}

constructor

constructor(exitCode: number);

property body

body: { exitCode: number };

class Handles

class Handles<T> {}

constructor

constructor(startHandle?: number);

method create

create: (value: T) => number;

method get

get: (handle: number, dflt?: T) => T;

method reset

reset: () => void;

class InitializedEvent

class InitializedEvent extends Event implements DebugProtocol.InitializedEvent {}

constructor

constructor();

class InvalidatedEvent

class InvalidatedEvent extends Event implements DebugProtocol.InvalidatedEvent {}

constructor

constructor(
    areas?: DebugProtocol.InvalidatedAreas[],
    threadId?: number,
    stackFrameId?: number
);

property body

body: {
    areas?: DebugProtocol.InvalidatedAreas[];
    threadId?: number;
    stackFrameId?: number;
};

class LoadedSourceEvent

class LoadedSourceEvent extends Event implements DebugProtocol.LoadedSourceEvent {}

constructor

constructor(reason: 'new' | 'changed' | 'removed', source: DebugProtocol.Source);

property body

body: { reason: 'new' | 'changed' | 'removed'; source: DebugProtocol.Source };

class LoggingDebugSession

class LoggingDebugSession extends DebugSession {}

constructor

constructor(
    obsolete_logFilePath?: string,
    obsolete_debuggerLinesAndColumnsStartAt1?: boolean,
    obsolete_isServer?: boolean
);

method dispatchRequest

protected dispatchRequest: (request: DebugProtocol.Request) => void;

method sendEvent

sendEvent: (event: DebugProtocol.Event) => void;

Overload sendEvent to log

method sendRequest

sendRequest: (
    command: string,
    args: any,
    timeout: number,
    cb: (response: DebugProtocol.Response) => void
) => void;

Overload sendRequest to log

method sendResponse

sendResponse: (response: DebugProtocol.Response) => void;

Overload sendResponse to log

method start

start: (
    inStream: NodeJS.ReadableStream,
    outStream: NodeJS.WritableStream
) => void;

class Module

class Module implements DebugProtocol.Module {}

constructor

constructor(id: string | number, name: string);

property id

id: string | number;

property name

name: string;

class ModuleEvent

class ModuleEvent extends Event implements DebugProtocol.ModuleEvent {}

constructor

constructor(reason: 'new' | 'changed' | 'removed', module: DebugProtocol.Module);

property body

body: { reason: 'new' | 'changed' | 'removed'; module: DebugProtocol.Module };

class OutputEvent

class OutputEvent extends Event implements DebugProtocol.OutputEvent {}

constructor

constructor(output: string, category?: string, data?: any);

property body

body: { category: string; output: string; data?: any };

class ProgressEndEvent

class ProgressEndEvent extends Event implements DebugProtocol.ProgressEndEvent {}

constructor

constructor(progressId: string, message?: string);

property body

body: { progressId: string };

class ProgressStartEvent

class ProgressStartEvent extends Event implements DebugProtocol.ProgressStartEvent {}

constructor

constructor(progressId: string, title: string, message?: string);

property body

body: { progressId: string; title: string };

class ProgressUpdateEvent

class ProgressUpdateEvent
    extends Event
    implements DebugProtocol.ProgressUpdateEvent {}

constructor

constructor(progressId: string, message?: string);

property body

body: { progressId: string };

class Response

class Response extends Message implements DebugProtocol.Response {}

constructor

constructor(request: DebugProtocol.Request, message?: string);

property command

command: string;

property request_seq

request_seq: number;

property success

success: boolean;

class Scope

class Scope implements DebugProtocol.Scope {}

constructor

constructor(name: string, reference: number, expensive?: boolean);

property expensive

expensive: boolean;

property name

name: string;

property variablesReference

variablesReference: number;

class Source

class Source implements DebugProtocol.Source {}

constructor

constructor(
    name: string,
    path?: string,
    id?: number,
    origin?: string,
    data?: any
);

property name

name: string;

property path

path: string;

property sourceReference

sourceReference: number;

class StackFrame

class StackFrame implements DebugProtocol.StackFrame {}

constructor

constructor(i: number, nm: string, src?: Source, ln?: number, col?: number);

property canRestart

canRestart?: boolean;

property column

column: number;

property endColumn

endColumn?: number;

property endLine

endLine?: number;

property id

id: number;

property instructionPointerReference

instructionPointerReference?: string;

property line

line: number;

property moduleId

moduleId?: string | number;

property name

name: string;

property presentationHint

presentationHint?: 'normal' | 'label' | 'subtle';

property source

source?: DebugProtocol.Source;

class StoppedEvent

class StoppedEvent extends Event implements DebugProtocol.StoppedEvent {}

constructor

constructor(reason: string, threadId?: number, exceptionText?: string);

property body

body: { reason: string };

class TerminatedEvent

class TerminatedEvent extends Event implements DebugProtocol.TerminatedEvent {}

constructor

constructor(restart?: any);

class Thread

class Thread implements DebugProtocol.Thread {}

constructor

constructor(id: number, name: string);

property id

id: number;

property name

name: string;

class ThreadEvent

class ThreadEvent extends Event implements DebugProtocol.ThreadEvent {}

constructor

constructor(reason: string, threadId: number);

property body

body: { reason: string; threadId: number };

class Variable

class Variable implements DebugProtocol.Variable {}

constructor

constructor(
    name: string,
    value: string,
    ref?: number,
    indexedVariables?: number,
    namedVariables?: number
);

property name

name: string;

property value

value: string;

property variablesReference

variablesReference: number;

Enums

enum ErrorDestination

enum ErrorDestination {
    User = 1,
    Telemetry = 2,
}

member Telemetry

Telemetry = 2

member User

User = 1

Namespaces

namespace Logger

module 'lib/logger.d.ts' {}

log adds a newline, write doesn't

variable logger

const logger: Logger;

function trimLastNewline

trimLastNewline: (str: string) => string;

class Logger

class Logger {}

method dispose

dispose: () => Promise<void>;

method error

error: (msg: string) => void;

method init

init: (
    logCallback: ILogCallback,
    logFilePath?: string,
    logToConsole?: boolean
) => void;

method log

log: (msg: string, level?: LogLevel) => void;

method setup

setup: (
    consoleMinLogLevel: LogLevel,
    _logFilePath?: string | boolean,
    prependTimestamp?: boolean
) => void;

Set the logger's minimum level to log in the console, and whether to log to the file. Log messages are queued before this is called the first time, because minLogLevel defaults to Warn.

method verbose

verbose: (msg: string) => void;

method warn

warn: (msg: string) => void;

class LogOutputEvent

class LogOutputEvent extends OutputEvent {}

constructor

constructor(msg: string, level: LogLevel);

interface IInternalLogger

interface IInternalLogger {}

method dispose

dispose: () => Promise<void>;

method log

log: (msg: string, level: LogLevel, prependTimestamp?: boolean) => void;

method setup

setup: (options: IInternalLoggerOptions) => Promise<void>;

interface IInternalLoggerOptions

interface IInternalLoggerOptions {}

property consoleMinLogLevel

consoleMinLogLevel: LogLevel;

property logFilePath

logFilePath?: string;

property prependTimestamp

prependTimestamp?: boolean;

interface ILogger

interface ILogger {}

method error

error: (msg: string) => void;

method log

log: (msg: string, level?: LogLevel) => void;

method verbose

verbose: (msg: string) => void;

method warn

warn: (msg: string) => void;

enum LogLevel

enum LogLevel {
    Verbose = 0,
    Log = 1,
    Warn = 2,
    Error = 3,
    Stop = 4,
}

member Error

Error = 3

member Log

Log = 1

member Stop

Stop = 4

member Verbose

Verbose = 0

member Warn

Warn = 2

type ILogCallback

type ILogCallback = (outputEvent: OutputEvent) => void;

Package Files (6)

Dependencies (2)

Dev Dependencies (5)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/vscode-debugadapter.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/vscode-debugadapter)

HTML

<a href="https://www.jsdocs.io/package/vscode-debugadapter"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 4215 ms.
Missing or incorrect documentation? Open an issue for this package.