@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/debug/common/debugSchemas.js

@@ -0,0 +1,346 @@
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { launchSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { inputsSchema } from '../../../services/configurationResolver/common/configurationResolverSchema.js';
+
+const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'debuggers',
+    defaultExtensionKind: ['workspace'],
+    jsonSchema: {
+        description: ( nls.localize('vscode.extension.contributes.debuggers', 'Contributes debug adapters.')),
+        type: 'array',
+        defaultSnippets: [{ body: [{ type: '' }] }],
+        items: {
+            additionalProperties: false,
+            type: 'object',
+            defaultSnippets: [{ body: { type: '', program: '', runtime: '' } }],
+            properties: {
+                type: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.type',
+                        "Unique identifier for this debug adapter."
+                    )),
+                    type: 'string'
+                },
+                label: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.label',
+                        "Display name for this debug adapter."
+                    )),
+                    type: 'string'
+                },
+                program: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.program',
+                        "Path to the debug adapter program. Path is either absolute or relative to the extension folder."
+                    )),
+                    type: 'string'
+                },
+                args: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.args',
+                        "Optional arguments to pass to the adapter."
+                    )),
+                    type: 'array'
+                },
+                runtime: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.runtime',
+                        "Optional runtime in case the program attribute is not an executable but requires a runtime."
+                    )),
+                    type: 'string'
+                },
+                runtimeArgs: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.runtimeArgs',
+                        "Optional runtime arguments."
+                    )),
+                    type: 'array'
+                },
+                variables: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.variables',
+                        "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
+                    )),
+                    type: 'object'
+                },
+                initialConfigurations: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.initialConfigurations',
+                        "Configurations for generating the initial \'launch.json\'."
+                    )),
+                    type: ['array', 'string'],
+                },
+                languages: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.languages',
+                        "List of languages for which the debug extension could be considered the \"default debugger\"."
+                    )),
+                    type: 'array'
+                },
+                configurationSnippets: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.configurationSnippets',
+                        "Snippets for adding new configurations in \'launch.json\'."
+                    )),
+                    type: 'array'
+                },
+                configurationAttributes: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.configurationAttributes',
+                        "JSON schema configurations for validating \'launch.json\'."
+                    )),
+                    type: 'object'
+                },
+                when: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.when',
+                        "Condition which must be true to enable this type of debugger. Consider using 'shellExecutionSupported', 'virtualWorkspace', 'resourceScheme' or an extension-defined context key as appropriate for this."
+                    )),
+                    type: 'string',
+                    default: ''
+                },
+                deprecated: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.deprecated',
+                        "Optional message to mark this debug type as being deprecated."
+                    )),
+                    type: 'string',
+                    default: ''
+                },
+                windows: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.windows',
+                        "Windows specific settings."
+                    )),
+                    type: 'object',
+                    properties: {
+                        runtime: {
+                            description: ( nls.localize(
+                                'vscode.extension.contributes.debuggers.windows.runtime',
+                                "Runtime used for Windows."
+                            )),
+                            type: 'string'
+                        }
+                    }
+                },
+                osx: {
+                    description: ( nls.localize('vscode.extension.contributes.debuggers.osx', "macOS specific settings.")),
+                    type: 'object',
+                    properties: {
+                        runtime: {
+                            description: ( nls.localize(
+                                'vscode.extension.contributes.debuggers.osx.runtime',
+                                "Runtime used for macOS."
+                            )),
+                            type: 'string'
+                        }
+                    }
+                },
+                linux: {
+                    description: ( nls.localize('vscode.extension.contributes.debuggers.linux', "Linux specific settings.")),
+                    type: 'object',
+                    properties: {
+                        runtime: {
+                            description: ( nls.localize(
+                                'vscode.extension.contributes.debuggers.linux.runtime',
+                                "Runtime used for Linux."
+                            )),
+                            type: 'string'
+                        }
+                    }
+                },
+                strings: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.debuggers.strings',
+                        "UI strings contributed by this debug adapter."
+                    )),
+                    type: 'object',
+                    properties: {
+                        unverifiedBreakpoints: {
+                            description: ( nls.localize(
+                                'vscode.extension.contributes.debuggers.strings.unverifiedBreakpoints',
+                                "When there are unverified breakpoints in a language supported by this debug adapter, this message will appear on the breakpoint hover and in the breakpoints view. Markdown and command links are supported."
+                            )),
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        }
+    }
+}));
+const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'breakpoints',
+    jsonSchema: {
+        description: ( nls.localize('vscode.extension.contributes.breakpoints', 'Contributes breakpoints.')),
+        type: 'array',
+        defaultSnippets: [{ body: [{ language: '' }] }],
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            defaultSnippets: [{ body: { language: '' } }],
+            properties: {
+                language: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.breakpoints.language',
+                        "Allow breakpoints for this language."
+                    )),
+                    type: 'string'
+                },
+                when: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.breakpoints.when',
+                        "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."
+                    )),
+                    type: 'string',
+                    default: ''
+                }
+            }
+        }
+    }
+}));
+const presentationSchema = {
+    type: 'object',
+    description: ( nls.localize(
+        'presentation',
+        "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."
+    )),
+    properties: {
+        hidden: {
+            type: 'boolean',
+            default: false,
+            description: ( nls.localize(
+                'presentation.hidden',
+                "Controls if this configuration should be shown in the configuration dropdown and the command palette."
+            ))
+        },
+        group: {
+            type: 'string',
+            default: '',
+            description: ( nls.localize(
+                'presentation.group',
+                "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette."
+            ))
+        },
+        order: {
+            type: 'number',
+            default: 1,
+            description: ( nls.localize(
+                'presentation.order',
+                "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette."
+            ))
+        }
+    },
+    default: {
+        hidden: false,
+        group: '',
+        order: 1
+    }
+};
+const defaultCompound = { name: 'Compound', configurations: [] };
+const launchSchema = {
+    id: launchSchemaId,
+    type: 'object',
+    title: ( nls.localize('app.launch.json.title', "Launch")),
+    allowTrailingCommas: true,
+    allowComments: true,
+    required: [],
+    default: { version: '0.2.0', configurations: [], compounds: [] },
+    properties: {
+        version: {
+            type: 'string',
+            description: ( nls.localize('app.launch.json.version', "Version of this file format.")),
+            default: '0.2.0'
+        },
+        configurations: {
+            type: 'array',
+            description: ( nls.localize(
+                'app.launch.json.configurations',
+                "List of configurations. Add new configurations or edit existing ones by using IntelliSense."
+            )),
+            items: {
+                defaultSnippets: [],
+                'type': 'object',
+                oneOf: []
+            }
+        },
+        compounds: {
+            type: 'array',
+            description: ( nls.localize(
+                'app.launch.json.compounds',
+                "List of compounds. Each compound references multiple configurations which will get launched together."
+            )),
+            items: {
+                type: 'object',
+                required: ['name', 'configurations'],
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'app.launch.json.compound.name',
+                            "Name of compound. Appears in the launch configuration drop down menu."
+                        ))
+                    },
+                    presentation: presentationSchema,
+                    configurations: {
+                        type: 'array',
+                        default: [],
+                        items: {
+                            oneOf: [{
+                                    enum: [],
+                                    description: ( nls.localize('useUniqueNames', "Please use unique configuration names."))
+                                }, {
+                                    type: 'object',
+                                    required: ['name'],
+                                    properties: {
+                                        name: {
+                                            enum: [],
+                                            description: ( nls.localize(
+                                                'app.launch.json.compound.name',
+                                                "Name of compound. Appears in the launch configuration drop down menu."
+                                            ))
+                                        },
+                                        folder: {
+                                            enum: [],
+                                            description: ( nls.localize(
+                                                'app.launch.json.compound.folder',
+                                                "Name of folder in which the compound is located."
+                                            ))
+                                        }
+                                    }
+                                }]
+                        },
+                        description: ( nls.localize(
+                            'app.launch.json.compounds.configurations',
+                            "Names of configurations that will be started as part of this compound."
+                        ))
+                    },
+                    stopAll: {
+                        type: 'boolean',
+                        default: false,
+                        description: ( nls.localize(
+                            'app.launch.json.compound.stopAll',
+                            "Controls whether manually terminating one session will stop all of the compound sessions."
+                        ))
+                    },
+                    preLaunchTask: {
+                        type: 'string',
+                        default: '',
+                        description: ( nls.localize(
+                            'compoundPrelaunchTask',
+                            "Task to run before any of the compound configurations start."
+                        ))
+                    }
+                },
+                default: defaultCompound
+            },
+            default: [
+                defaultCompound
+            ]
+        },
+        inputs: inputsSchema.definitions.inputs
+    }
+};
+
+export { breakpointsExtPoint, debuggersExtPoint, launchSchema, presentationSchema };

package/vscode/src/vs/workbench/contrib/debug/common/debugSource.js

@@ -0,0 +1,123 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { normalize, isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { DEBUG_SCHEME } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { SIDE_GROUP, ACTIVE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isUri } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+
+const UNKNOWN_SOURCE_LABEL = ( nls.localize('unknownSource', "Unknown Source"));
+class Source {
+    constructor(raw_, sessionId, uriIdentityService, logService) {
+        let path;
+        if (raw_) {
+            this.raw = raw_;
+            path = this.raw.path || this.raw.name || '';
+            this.available = true;
+        }
+        else {
+            this.raw = { name: UNKNOWN_SOURCE_LABEL };
+            this.available = false;
+            path = `${DEBUG_SCHEME}:${UNKNOWN_SOURCE_LABEL}`;
+        }
+        this.uri = getUriFromSource(this.raw, path, sessionId, uriIdentityService, logService);
+    }
+    get name() {
+        return this.raw.name || resources.basenameOrAuthority(this.uri);
+    }
+    get origin() {
+        return this.raw.origin;
+    }
+    get presentationHint() {
+        return this.raw.presentationHint;
+    }
+    get reference() {
+        return this.raw.sourceReference;
+    }
+    get inMemory() {
+        return this.uri.scheme === DEBUG_SCHEME;
+    }
+    openInEditor(editorService, selection, preserveFocus, sideBySide, pinned) {
+        return !this.available ? Promise.resolve(undefined) : editorService.openEditor({
+            resource: this.uri,
+            description: this.origin,
+            options: {
+                preserveFocus,
+                selection,
+                revealIfOpened: true,
+                selectionRevealType: 1 ,
+                pinned
+            }
+        }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+    }
+    static getEncodedDebugData(modelUri) {
+        let path;
+        let sourceReference;
+        let sessionId;
+        switch (modelUri.scheme) {
+            case Schemas.file:
+                path = normalize(modelUri.fsPath);
+                break;
+            case DEBUG_SCHEME:
+                path = modelUri.path;
+                if (modelUri.query) {
+                    const keyvalues = modelUri.query.split('&');
+                    for (const keyvalue of keyvalues) {
+                        const pair = keyvalue.split('=');
+                        if (pair.length === 2) {
+                            switch (pair[0]) {
+                                case 'session':
+                                    sessionId = pair[1];
+                                    break;
+                                case 'ref':
+                                    sourceReference = parseInt(pair[1]);
+                                    break;
+                            }
+                        }
+                    }
+                }
+                break;
+            default:
+                path = ( modelUri.toString());
+                break;
+        }
+        return {
+            name: resources.basenameOrAuthority(modelUri),
+            path,
+            sourceReference,
+            sessionId
+        };
+    }
+}
+function getUriFromSource(raw, path, sessionId, uriIdentityService, logService) {
+    const _getUriFromSource = (path) => {
+        if (typeof raw.sourceReference === 'number' && raw.sourceReference > 0) {
+            return ( URI.from({
+                scheme: DEBUG_SCHEME,
+                path,
+                query: `session=${sessionId}&ref=${raw.sourceReference}`
+            }));
+        }
+        if (path && isUri(path)) {
+            return uriIdentityService.asCanonicalUri(( URI.parse(path)));
+        }
+        if (path && isAbsolute(path)) {
+            return uriIdentityService.asCanonicalUri(URI.file(path));
+        }
+        return uriIdentityService.asCanonicalUri(( URI.from({
+            scheme: DEBUG_SCHEME,
+            path,
+            query: `session=${sessionId}`
+        })));
+    };
+    try {
+        return _getUriFromSource(path);
+    }
+    catch (err) {
+        logService.error('Invalid path from debug adapter: ' + path);
+        return _getUriFromSource('/invalidDebugSource');
+    }
+}
+
+export { Source, UNKNOWN_SOURCE_LABEL, getUriFromSource };

package/vscode/src/vs/workbench/contrib/debug/common/debugStorage.js

@@ -0,0 +1,175 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Breakpoint, FunctionBreakpoint, ExceptionBreakpoint, DataBreakpoint, Expression } from './debugModel.js';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+const DEBUG_BREAKPOINTS_KEY = 'debug.breakpoint';
+const DEBUG_FUNCTION_BREAKPOINTS_KEY = 'debug.functionbreakpoint';
+const DEBUG_DATA_BREAKPOINTS_KEY = 'debug.databreakpoint';
+const DEBUG_EXCEPTION_BREAKPOINTS_KEY = 'debug.exceptionbreakpoint';
+const DEBUG_WATCH_EXPRESSIONS_KEY = 'debug.watchexpressions';
+const DEBUG_CHOSEN_ENVIRONMENTS_KEY = 'debug.chosenenvironment';
+const DEBUG_UX_STATE_KEY = 'debug.uxstate';
+let DebugStorage = class DebugStorage extends Disposable {
+    constructor(storageService, textFileService, uriIdentityService, logService) {
+        super();
+        this.storageService = storageService;
+        this.textFileService = textFileService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this.breakpoints = observableValue('debugBreakpoints', this.loadBreakpoints());
+        this.functionBreakpoints = observableValue('debugFunctionBreakpoints', this.loadFunctionBreakpoints());
+        this.exceptionBreakpoints = observableValue('debugExceptionBreakpoints', this.loadExceptionBreakpoints());
+        this.dataBreakpoints = observableValue('debugDataBreakpoints', this.loadDataBreakpoints());
+        this.watchExpressions = observableValue('debugWatchExpressions', this.loadWatchExpressions());
+        this._register(storageService.onDidChangeValue(1 , undefined, this._store)(e => {
+            if (e.external) {
+                switch (e.key) {
+                    case DEBUG_BREAKPOINTS_KEY:
+                        return this.breakpoints.set(this.loadBreakpoints(), undefined);
+                    case DEBUG_FUNCTION_BREAKPOINTS_KEY:
+                        return this.functionBreakpoints.set(this.loadFunctionBreakpoints(), undefined);
+                    case DEBUG_EXCEPTION_BREAKPOINTS_KEY:
+                        return this.exceptionBreakpoints.set(this.loadExceptionBreakpoints(), undefined);
+                    case DEBUG_DATA_BREAKPOINTS_KEY:
+                        return this.dataBreakpoints.set(this.loadDataBreakpoints(), undefined);
+                    case DEBUG_WATCH_EXPRESSIONS_KEY:
+                        return this.watchExpressions.set(this.loadWatchExpressions(), undefined);
+                }
+            }
+        }));
+    }
+    loadDebugUxState() {
+        return this.storageService.get(DEBUG_UX_STATE_KEY, 1 , 'default');
+    }
+    storeDebugUxState(value) {
+        this.storageService.store(DEBUG_UX_STATE_KEY, value, 1 , 1 );
+    }
+    loadBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_BREAKPOINTS_KEY, 1 , '[]')).map((breakpoint) => {
+                return ( new Breakpoint(( URI.parse(breakpoint.uri.external || breakpoint.source.uri.external)), breakpoint.lineNumber, breakpoint.column, breakpoint.enabled, breakpoint.condition, breakpoint.hitCondition, breakpoint.logMessage, breakpoint.adapterData, this.textFileService, this.uriIdentityService, this.logService, breakpoint.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadFunctionBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 , '[]')).map((fb) => {
+                return ( new FunctionBreakpoint(fb.name, fb.enabled, fb.hitCondition, fb.condition, fb.logMessage, fb.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadExceptionBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 , '[]')).map((exBreakpoint) => {
+                return ( new ExceptionBreakpoint(
+                    exBreakpoint.filter,
+                    exBreakpoint.label,
+                    exBreakpoint.enabled,
+                    exBreakpoint.supportsCondition,
+                    exBreakpoint.condition,
+                    exBreakpoint.description,
+                    exBreakpoint.conditionDescription,
+                    !!exBreakpoint.fallback
+                ));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadDataBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_DATA_BREAKPOINTS_KEY, 1 , '[]')).map((dbp) => {
+                return ( new DataBreakpoint(
+                    dbp.description,
+                    dbp.dataId,
+                    true,
+                    dbp.enabled,
+                    dbp.hitCondition,
+                    dbp.condition,
+                    dbp.logMessage,
+                    dbp.accessTypes,
+                    dbp.accessType,
+                    dbp.id
+                ));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadWatchExpressions() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_WATCH_EXPRESSIONS_KEY, 1 , '[]')).map((watchStoredData) => {
+                return ( new Expression(watchStoredData.name, watchStoredData.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadChosenEnvironments() {
+        return JSON.parse(this.storageService.get(DEBUG_CHOSEN_ENVIRONMENTS_KEY, 1 , '{}'));
+    }
+    storeChosenEnvironments(environments) {
+        this.storageService.store(DEBUG_CHOSEN_ENVIRONMENTS_KEY, JSON.stringify(environments), 1 , 1 );
+    }
+    storeWatchExpressions(watchExpressions) {
+        if (watchExpressions.length) {
+            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({ name: we.name, id: we.getId() })))), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_WATCH_EXPRESSIONS_KEY, 1 );
+        }
+    }
+    storeBreakpoints(debugModel) {
+        const breakpoints = debugModel.getBreakpoints();
+        if (breakpoints.length) {
+            this.storageService.store(DEBUG_BREAKPOINTS_KEY, JSON.stringify(breakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_BREAKPOINTS_KEY, 1 );
+        }
+        const functionBreakpoints = debugModel.getFunctionBreakpoints();
+        if (functionBreakpoints.length) {
+            this.storageService.store(DEBUG_FUNCTION_BREAKPOINTS_KEY, JSON.stringify(functionBreakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 );
+        }
+        const dataBreakpoints = debugModel.getDataBreakpoints().filter(dbp => dbp.canPersist);
+        if (dataBreakpoints.length) {
+            this.storageService.store(DEBUG_DATA_BREAKPOINTS_KEY, JSON.stringify(dataBreakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_DATA_BREAKPOINTS_KEY, 1 );
+        }
+        const exceptionBreakpoints = debugModel.getExceptionBreakpoints();
+        if (exceptionBreakpoints.length) {
+            this.storageService.store(DEBUG_EXCEPTION_BREAKPOINTS_KEY, JSON.stringify(exceptionBreakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 );
+        }
+    }
+};
+DebugStorage = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, ILogService))
+], DebugStorage));
+
+export { DebugStorage };

package/vscode/src/vs/workbench/contrib/debug/common/debugTelemetry.js

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+
+let DebugTelemetry = class DebugTelemetry {
+    constructor(model, telemetryService) {
+        this.model = model;
+        this.telemetryService = telemetryService;
+    }
+    logDebugSessionStart(dbgr, launchJsonExists) {
+        const extension = dbgr.getMainExtensionDescriptor();
+        this.telemetryService.publicLog('debugSessionStart', {
+            type: dbgr.type,
+            breakpointCount: this.model.getBreakpoints().length,
+            exceptionBreakpoints: this.model.getExceptionBreakpoints(),
+            watchExpressionsCount: this.model.getWatchExpressions().length,
+            extensionName: extension.identifier.value,
+            isBuiltin: extension.isBuiltin,
+            launchJsonExists
+        });
+    }
+    logDebugSessionStop(session, adapterExitEvent) {
+        const breakpoints = this.model.getBreakpoints();
+        this.telemetryService.publicLog('debugSessionStop', {
+            type: session && session.configuration.type,
+            success: adapterExitEvent.emittedStopped || breakpoints.length === 0,
+            sessionLengthInSeconds: adapterExitEvent.sessionLengthInSeconds,
+            breakpointCount: breakpoints.length,
+            watchExpressionsCount: this.model.getWatchExpressions().length
+        });
+    }
+};
+DebugTelemetry = ( __decorate([
+    ( __param(1, ITelemetryService))
+], DebugTelemetry));
+
+export { DebugTelemetry };