@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

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

@@ -1,115 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { CONTEXT_EXPRESSION_SELECTED, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE } from './debug.js';
-import { isSessionAttach } from './debugUtils.js';
-class ViewModel {
-    constructor(contextKeyService) {
-        this.contextKeyService = contextKeyService;
-        this.firstSessionStart = true;
-        this._onDidFocusSession = ( new Emitter());
-        this._onDidFocusThread = ( new Emitter());
-        this._onDidFocusStackFrame = ( new Emitter());
-        this._onDidSelectExpression = ( new Emitter());
-        this._onDidEvaluateLazyExpression = ( new Emitter());
-        this._onWillUpdateViews = ( new Emitter());
-        contextKeyService.bufferChangeEvents(() => {
-            this.expressionSelectedContextKey = CONTEXT_EXPRESSION_SELECTED.bindTo(contextKeyService);
-            this.loadedScriptsSupportedContextKey = CONTEXT_LOADED_SCRIPTS_SUPPORTED.bindTo(contextKeyService);
-            this.stepBackSupportedContextKey = CONTEXT_STEP_BACK_SUPPORTED.bindTo(contextKeyService);
-            this.focusedSessionIsAttach = CONTEXT_FOCUSED_SESSION_IS_ATTACH.bindTo(contextKeyService);
-            this.restartFrameSupportedContextKey = CONTEXT_RESTART_FRAME_SUPPORTED.bindTo(contextKeyService);
-            this.stepIntoTargetsSupported = CONTEXT_STEP_INTO_TARGETS_SUPPORTED.bindTo(contextKeyService);
-            this.jumpToCursorSupported = CONTEXT_JUMP_TO_CURSOR_SUPPORTED.bindTo(contextKeyService);
-            this.setVariableSupported = CONTEXT_SET_VARIABLE_SUPPORTED.bindTo(contextKeyService);
-            this.setExpressionSupported = CONTEXT_SET_EXPRESSION_SUPPORTED.bindTo(contextKeyService);
-            this.multiSessionDebug = CONTEXT_MULTI_SESSION_DEBUG.bindTo(contextKeyService);
-            this.terminateDebuggeeSupported = CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED.bindTo(contextKeyService);
-            this.suspendDebuggeeSupported = CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED.bindTo(contextKeyService);
-            this.disassembleRequestSupported = CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED.bindTo(contextKeyService);
-            this.focusedStackFrameHasInstructionPointerReference = CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE.bindTo(contextKeyService);
-        });
-    }
-    getId() {
-        return 'root';
-    }
-    get focusedSession() {
-        return this._focusedSession;
-    }
-    get focusedThread() {
-        return this._focusedThread;
-    }
-    get focusedStackFrame() {
-        return this._focusedStackFrame;
-    }
-    setFocus(stackFrame, thread, session, explicit) {
-        const shouldEmitForStackFrame = this._focusedStackFrame !== stackFrame;
-        const shouldEmitForSession = this._focusedSession !== session;
-        const shouldEmitForThread = this._focusedThread !== thread;
-        this._focusedStackFrame = stackFrame;
-        this._focusedThread = thread;
-        this._focusedSession = session;
-        this.contextKeyService.bufferChangeEvents(() => {
-            this.loadedScriptsSupportedContextKey.set(session ? !!session.capabilities.supportsLoadedSourcesRequest : false);
-            this.stepBackSupportedContextKey.set(session ? !!session.capabilities.supportsStepBack : false);
-            this.restartFrameSupportedContextKey.set(session ? !!session.capabilities.supportsRestartFrame : false);
-            this.stepIntoTargetsSupported.set(session ? !!session.capabilities.supportsStepInTargetsRequest : false);
-            this.jumpToCursorSupported.set(session ? !!session.capabilities.supportsGotoTargetsRequest : false);
-            this.setVariableSupported.set(session ? !!session.capabilities.supportsSetVariable : false);
-            this.setExpressionSupported.set(session ? !!session.capabilities.supportsSetExpression : false);
-            this.terminateDebuggeeSupported.set(session ? !!session.capabilities.supportTerminateDebuggee : false);
-            this.suspendDebuggeeSupported.set(session ? !!session.capabilities.supportSuspendDebuggee : false);
-            this.disassembleRequestSupported.set(!!session?.capabilities.supportsDisassembleRequest);
-            this.focusedStackFrameHasInstructionPointerReference.set(!!stackFrame?.instructionPointerReference);
-            const attach = !!session && isSessionAttach(session);
-            this.focusedSessionIsAttach.set(attach);
-        });
-        if (shouldEmitForSession) {
-            this._onDidFocusSession.fire(session);
-        }
-        if (shouldEmitForStackFrame) {
-            this._onDidFocusStackFrame.fire({ stackFrame, explicit, session });
-        }
-        else if (shouldEmitForThread) {
-            this._onDidFocusThread.fire({ thread, explicit, session });
-        }
-    }
-    get onDidFocusSession() {
-        return this._onDidFocusSession.event;
-    }
-    get onDidFocusThread() {
-        return this._onDidFocusThread.event;
-    }
-    get onDidFocusStackFrame() {
-        return this._onDidFocusStackFrame.event;
-    }
-    getSelectedExpression() {
-        return this.selectedExpression;
-    }
-    setSelectedExpression(expression, settingWatch) {
-        this.selectedExpression = expression ? { expression, settingWatch: settingWatch } : undefined;
-        this.expressionSelectedContextKey.set(!!expression);
-        this._onDidSelectExpression.fire(this.selectedExpression);
-    }
-    get onDidSelectExpression() {
-        return this._onDidSelectExpression.event;
-    }
-    get onDidEvaluateLazyExpression() {
-        return this._onDidEvaluateLazyExpression.event;
-    }
-    updateViews() {
-        this._onWillUpdateViews.fire();
-    }
-    get onWillUpdateViews() {
-        return this._onWillUpdateViews.event;
-    }
-    isMultiSessionView() {
-        return !!this.multiSessionDebug.get();
-    }
-    setMultiSessionView(isMultiSessionView) {
-        this.multiSessionDebug.set(isMultiSessionView);
-    }
-    async evaluateLazyExpression(expression) {
-        await expression.evaluateLazy();
-        this._onDidEvaluateLazyExpression.fire(expression);
-    }
-}
-export { ViewModel };

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

@@ -1,258 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { debuggerDisabledMessage, IDebugService } from './debug.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
-import { applyDeprecatedVariableMessage } from '../../../services/configurationResolver/common/configurationResolverUtils.js';
-import { ITextResourcePropertiesService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isDebuggerMainContribution } from './debugUtils.js';
-import { cleanRemoteAuthority } from '../../../../platform/telemetry/common/telemetryUtils.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { filter } from 'monaco-editor/esm/vs/base/common/objects.js';
-let Debugger = class Debugger {
-    constructor(adapterManager, dbgContribution, extensionDescription, configurationService, resourcePropertiesService, configurationResolverService, environmentService, debugService, contextKeyService) {
-        this.adapterManager = adapterManager;
-        this.configurationService = configurationService;
-        this.resourcePropertiesService = resourcePropertiesService;
-        this.configurationResolverService = configurationResolverService;
-        this.environmentService = environmentService;
-        this.debugService = debugService;
-        this.contextKeyService = contextKeyService;
-        this.mergedExtensionDescriptions = [];
-        this.debuggerContribution = { type: dbgContribution.type };
-        this.merge(dbgContribution, extensionDescription);
-        this.debuggerWhen = typeof this.debuggerContribution.when === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.when) : undefined;
-    }
-    merge(otherDebuggerContribution, extensionDescription) {
-        function mixin(destination, source, overwrite, level = 0) {
-            if (!isObject(destination)) {
-                return source;
-            }
-            if (isObject(source)) {
-                ( Object.keys(source)).forEach(key => {
-                    if (key !== '__proto__') {
-                        if (isObject(destination[key]) && isObject(source[key])) {
-                            mixin(destination[key], source[key], overwrite, level + 1);
-                        }
-                        else {
-                            if (key in destination) {
-                                if (overwrite) {
-                                    if (level === 0 && key === 'type') ;
-                                    else {
-                                        destination[key] = source[key];
-                                    }
-                                }
-                            }
-                            else {
-                                destination[key] = source[key];
-                            }
-                        }
-                    }
-                });
-            }
-            return destination;
-        }
-        if (this.mergedExtensionDescriptions.indexOf(extensionDescription) < 0) {
-            this.mergedExtensionDescriptions.push(extensionDescription);
-            mixin(this.debuggerContribution, otherDebuggerContribution, extensionDescription.isBuiltin);
-            if (isDebuggerMainContribution(otherDebuggerContribution)) {
-                this.mainExtensionDescription = extensionDescription;
-            }
-        }
-    }
-    async startDebugging(configuration, parentSessionId) {
-        const parentSession = this.debugService.getModel().getSession(parentSessionId);
-        return await this.debugService.startDebugging(undefined, configuration, { parentSession }, undefined);
-    }
-    async createDebugAdapter(session) {
-        await this.adapterManager.activateDebuggers('onDebugAdapterProtocolTracker', this.type);
-        const da = this.adapterManager.createDebugAdapter(session);
-        if (da) {
-            return Promise.resolve(da);
-        }
-        throw new Error(nls.localize('cannot.find.da', "Cannot find debug adapter for type '{0}'.", this.type));
-    }
-    async substituteVariables(folder, config) {
-        const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
-        return await this.configurationResolverService.resolveWithInteractionReplace(folder, substitutedConfig, 'launch', this.variables, substitutedConfig.__configurationTarget);
-    }
-    runInTerminal(args, sessionId) {
-        return this.adapterManager.runInTerminal(this.type, args, sessionId);
-    }
-    get label() {
-        return this.debuggerContribution.label || this.debuggerContribution.type;
-    }
-    get type() {
-        return this.debuggerContribution.type;
-    }
-    get variables() {
-        return this.debuggerContribution.variables;
-    }
-    get configurationSnippets() {
-        return this.debuggerContribution.configurationSnippets;
-    }
-    get languages() {
-        return this.debuggerContribution.languages;
-    }
-    get when() {
-        return this.debuggerWhen;
-    }
-    get enabled() {
-        return !this.debuggerWhen || this.contextKeyService.contextMatchesRules(this.debuggerWhen);
-    }
-    get strings() {
-        return this.debuggerContribution.strings ?? this.debuggerContribution.uiMessages;
-    }
-    interestedInLanguage(languageId) {
-        return !!(this.languages && this.languages.indexOf(languageId) >= 0);
-    }
-    hasInitialConfiguration() {
-        return !!this.debuggerContribution.initialConfigurations;
-    }
-    hasConfigurationProvider() {
-        return this.debugService.getConfigurationManager().hasDebugConfigurationProvider(this.type);
-    }
-    getInitialConfigurationContent(initialConfigs) {
-        let initialConfigurations = this.debuggerContribution.initialConfigurations || [];
-        if (initialConfigs) {
-            initialConfigurations = initialConfigurations.concat(initialConfigs);
-        }
-        const eol = this.resourcePropertiesService.getEOL(( URI.from({ scheme: Schemas.untitled, path: '1' }))) === '\r\n' ? '\r\n' : '\n';
-        const configs = ( JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line)).join(eol).trim();
-        const comment1 = ( nls.localize(
-            'launch.config.comment1',
-            "Use IntelliSense to learn about possible attributes."
-        ));
-        const comment2 = ( nls.localize(
-            'launch.config.comment2',
-            "Hover to view descriptions of existing attributes."
-        ));
-        const comment3 = ( nls.localize(
-            'launch.config.comment3',
-            "For more information, visit: {0}",
-            'https://go.microsoft.com/fwlink/?linkid=830387'
-        ));
-        let content = [
-            '{',
-            `\t// ${comment1}`,
-            `\t// ${comment2}`,
-            `\t// ${comment3}`,
-            `\t"version": "0.2.0",`,
-            `\t"configurations": ${configs}`,
-            '}'
-        ].join(eol);
-        const editorConfig = this.configurationService.getValue();
-        if (editorConfig.editor && editorConfig.editor.insertSpaces) {
-            content = content.replace(( new RegExp('\t', 'g')), ' '.repeat(editorConfig.editor.tabSize));
-        }
-        return Promise.resolve(content);
-    }
-    getMainExtensionDescriptor() {
-        return this.mainExtensionDescription || this.mergedExtensionDescriptions[0];
-    }
-    getCustomTelemetryEndpoint() {
-        const aiKey = this.debuggerContribution.aiKey;
-        if (!aiKey) {
-            return undefined;
-        }
-        const sendErrorTelemtry = cleanRemoteAuthority(this.environmentService.remoteAuthority) !== 'other';
-        return {
-            id: `${this.getMainExtensionDescriptor().publisher}.${this.type}`,
-            aiKey,
-            sendErrorTelemetry: sendErrorTelemtry
-        };
-    }
-    getSchemaAttributes(definitions) {
-        if (!this.debuggerContribution.configurationAttributes) {
-            return null;
-        }
-        return ( ( Object.keys(this.debuggerContribution.configurationAttributes)).map(request => {
-            const definitionId = `${this.type}:${request}`;
-            const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
-            const attributes = this.debuggerContribution.configurationAttributes[request];
-            const defaultRequired = ['name', 'type', 'request'];
-            attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
-            attributes.additionalProperties = false;
-            attributes.type = 'object';
-            if (!attributes.properties) {
-                attributes.properties = {};
-            }
-            const properties = attributes.properties;
-            properties['type'] = {
-                enum: [this.type],
-                enumDescriptions: [this.label],
-                description: ( nls.localize('debugType', "Type of configuration.")),
-                pattern: '^(?!node2)',
-                deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
-                doNotSuggest: !!this.debuggerContribution.deprecated,
-                errorMessage: ( nls.localize(
-                    'debugTypeNotRecognised',
-                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
-                )),
-                patternErrorMessage: ( nls.localize(
-                    'node2NotSupported',
-                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
-                ))
-            };
-            properties['request'] = {
-                enum: [request],
-                description: ( nls.localize(
-                    'debugRequest',
-                    "Request type of configuration. Can be \"launch\" or \"attach\"."
-                )),
-            };
-            for (const prop in definitions['common'].properties) {
-                properties[prop] = {
-                    $ref: `#/definitions/common/properties/${prop}`
-                };
-            }
-            ( Object.keys(properties)).forEach(name => {
-                applyDeprecatedVariableMessage(properties[name]);
-            });
-            definitions[definitionId] = { ...attributes };
-            definitions[platformSpecificDefinitionId] = {
-                type: 'object',
-                additionalProperties: false,
-                properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
-            };
-            const attributesCopy = { ...attributes };
-            attributesCopy.properties = {
-                ...properties,
-                ...{
-                    windows: {
-                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( nls.localize(
-                            'debugWindowsConfiguration',
-                            "Windows specific launch configuration attributes."
-                        )),
-                    },
-                    osx: {
-                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( nls.localize('debugOSXConfiguration', "OS X specific launch configuration attributes.")),
-                    },
-                    linux: {
-                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( nls.localize(
-                            'debugLinuxConfiguration',
-                            "Linux specific launch configuration attributes."
-                        )),
-                    }
-                }
-            };
-            return attributesCopy;
-        }));
-    }
-};
-Debugger = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITextResourcePropertiesService)),
-    ( __param(5, IConfigurationResolverService)),
-    ( __param(6, IWorkbenchEnvironmentService)),
-    ( __param(7, IDebugService)),
-    ( __param(8, IContextKeyService))
-], Debugger));
-export { Debugger };

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

@@ -1,25 +0,0 @@
-import { EditorInput } from '../../../common/editor/editorInput.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-class DisassemblyViewInput extends EditorInput {
-    constructor() {
-        super(...arguments);
-        this.resource = undefined;
-    }
-    static { this.ID = 'debug.disassemblyView.input'; }
-    get typeId() {
-        return DisassemblyViewInput.ID;
-    }
-    static get instance() {
-        if (!DisassemblyViewInput._instance || DisassemblyViewInput._instance.isDisposed()) {
-            DisassemblyViewInput._instance = ( new DisassemblyViewInput());
-        }
-        return DisassemblyViewInput._instance;
-    }
-    getName() {
-        return ( localize('disassemblyInputName', "Disassembly"));
-    }
-    matches(other) {
-        return other instanceof DisassemblyViewInput;
-    }
-}
-export { DisassemblyViewInput };

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

@@ -1,81 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { IDebugService } from './debug.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-async function showLoadedScriptMenu(accessor) {
-    const quickInputService = accessor.get(IQuickInputService);
-    const debugService = accessor.get(IDebugService);
-    const editorService = accessor.get(IEditorService);
-    const sessions = debugService.getModel().getSessions(false);
-    const modelService = accessor.get(IModelService);
-    const languageService = accessor.get(ILanguageService);
-    const labelService = accessor.get(ILabelService);
-    const localDisposableStore = ( new DisposableStore());
-    const quickPick = quickInputService.createQuickPick();
-    localDisposableStore.add(quickPick);
-    quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
-    quickPick.placeholder = ( nls.localize('moveFocusedView.selectView', "Search loaded scripts by name"));
-    quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
-    localDisposableStore.add(quickPick.onDidChangeValue(async () => {
-        quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
-    }));
-    localDisposableStore.add(quickPick.onDidAccept(() => {
-        const selectedItem = quickPick.selectedItems[0];
-        selectedItem.accept();
-        quickPick.hide();
-        localDisposableStore.dispose();
-    }));
-    quickPick.show();
-}
-async function _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService) {
-    const items = [];
-    items.push({ type: 'separator', label: session.name });
-    const sources = await session.getLoadedSources();
-    sources.forEach((element) => {
-        const pick = _createPick(element, filter, editorService, modelService, languageService, labelService);
-        if (pick) {
-            items.push(pick);
-        }
-    });
-    return items;
-}
-async function _getPicks(filter, sessions, editorService, modelService, languageService, labelService) {
-    const loadedScriptPicks = [];
-    const picks = await Promise.all(( sessions.map(
-        (session) => _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService)
-    )));
-    for (const row of picks) {
-        for (const elem of row) {
-            loadedScriptPicks.push(elem);
-        }
-    }
-    return loadedScriptPicks;
-}
-function _createPick(source, filter, editorService, modelService, languageService, labelService) {
-    const label = labelService.getUriBasenameLabel(source.uri);
-    const desc = labelService.getUriLabel(dirname(source.uri));
-    const labelHighlights = matchesFuzzy(filter, label, true);
-    const descHighlights = matchesFuzzy(filter, desc, true);
-    if (labelHighlights || descHighlights) {
-        return {
-            label,
-            description: desc === '.' ? undefined : desc,
-            highlights: { label: labelHighlights ?? undefined, description: descHighlights ?? undefined },
-            iconClasses: getIconClasses(modelService, languageService, source.uri),
-            accept: () => {
-                if (source.available) {
-                    source.openInEditor(editorService, { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 });
-                }
-            }
-        };
-    }
-    return undefined;
-}
-export { showLoadedScriptMenu };