@codingame/monaco-vscode-api 4.1.0 → 4.1.2

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

@@ -1,15 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-class DebugCompoundRoot {
-    constructor() {
-        this.stopped = false;
-        this.stopEmitter = ( new Emitter());
-        this.onDidSessionStop = this.stopEmitter.event;
-    }
-    sessionStopped() {
-        if (!this.stopped) {
-            this.stopped = true;
-            this.stopEmitter.fire();
-        }
-    }
-}
-export { DebugCompoundRoot };

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

@@ -1,108 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { getMimeTypes } from '../../../../editor/common/services/languagesAssociations.js';
-import { IModelService } from '../../../../editor/common/services/model.js';
-import { ILanguageService } from '../../../../editor/common/languages/language.js';
-import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
-import { DEBUG_SCHEME, IDebugService } from './debug.js';
-import { Source } from './debugSource.js';
-import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
-import { EditOperation } from '../../../../editor/common/core/editOperation.js';
-import { Range } from '../../../../editor/common/core/range.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { PLAINTEXT_LANGUAGE_ID } from '../../../../editor/common/languages/modesRegistry.js';
-import { ErrorNoTelemetry } from '../../../../base/common/errors.js';
-var DebugContentProvider_1;
-let DebugContentProvider = class DebugContentProvider {
-    static { DebugContentProvider_1 = this; }
-    constructor(textModelResolverService, debugService, modelService, languageService, editorWorkerService) {
-        this.debugService = debugService;
-        this.modelService = modelService;
-        this.languageService = languageService;
-        this.editorWorkerService = editorWorkerService;
-        this.pendingUpdates = ( new Map());
-        textModelResolverService.registerTextModelContentProvider(DEBUG_SCHEME, this);
-        DebugContentProvider_1.INSTANCE = this;
-    }
-    dispose() {
-        this.pendingUpdates.forEach(cancellationSource => cancellationSource.dispose());
-    }
-    provideTextContent(resource) {
-        return this.createOrUpdateContentModel(resource, true);
-    }
-    static refreshDebugContent(resource) {
-        DebugContentProvider_1.INSTANCE?.createOrUpdateContentModel(resource, false);
-    }
-    createOrUpdateContentModel(resource, createIfNotExists) {
-        const model = this.modelService.getModel(resource);
-        if (!model && !createIfNotExists) {
-            return null;
-        }
-        let session;
-        if (resource.query) {
-            const data = Source.getEncodedDebugData(resource);
-            session = this.debugService.getModel().getSession(data.sessionId);
-        }
-        if (!session) {
-            session = this.debugService.getViewModel().focusedSession;
-        }
-        if (!session) {
-            return Promise.reject(( new ErrorNoTelemetry(( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugContentProvider',
-                'unable',
-                "Unable to resolve the resource without a debug session"
-            )))));
-        }
-        const createErrModel = (errMsg) => {
-            this.debugService.sourceIsNotAvailable(resource);
-            const languageSelection = this.languageService.createById(PLAINTEXT_LANGUAGE_ID);
-            const message = errMsg
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugContentProvider',
-                'canNotResolveSourceWithError',
-                "Could not load source '{0}': {1}.",
-                resource.path,
-                errMsg
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugContentProvider',
-                'canNotResolveSource',
-                "Could not load source '{0}'.",
-                resource.path
-            ));
-            return this.modelService.createModel(message, languageSelection, resource);
-        };
-        return session.loadSource(resource).then(response => {
-            if (response && response.body) {
-                if (model) {
-                    const newContent = response.body.content;
-                    const cancellationSource = this.pendingUpdates.get(model.id);
-                    cancellationSource?.cancel();
-                    const myToken = ( new CancellationTokenSource());
-                    this.pendingUpdates.set(model.id, myToken);
-                    return this.editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: newContent, range: model.getFullModelRange() }]).then(edits => {
-                        this.pendingUpdates.delete(model.id);
-                        if (!myToken.token.isCancellationRequested && edits && edits.length > 0) {
-                            model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
-                        }
-                        return model;
-                    });
-                }
-                else {
-                    const mime = response.body.mimeType || getMimeTypes(resource)[0];
-                    const languageSelection = this.languageService.createByMimeType(mime);
-                    return this.modelService.createModel(response.body.content, languageSelection, resource);
-                }
-            }
-            return createErrModel();
-        }, (err) => createErrModel(err.message));
-    }
-};
-DebugContentProvider = DebugContentProvider_1 = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, IEditorWorkerService))
-], DebugContentProvider));
-export { DebugContentProvider };

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

@@ -1,60 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IDebugService } from './debug.js';
-import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-let DebugLifecycle = class DebugLifecycle {
-    constructor(lifecycleService, debugService, configurationService, dialogService) {
-        this.debugService = debugService;
-        this.configurationService = configurationService;
-        this.dialogService = dialogService;
-        lifecycleService.onBeforeShutdown(async (e) => e.veto(this.shouldVetoShutdown(e.reason), 'veto.debug'));
-    }
-    shouldVetoShutdown(_reason) {
-        const rootSessions = this.debugService.getModel().getSessions().filter(s => s.parentSession === undefined);
-        if (rootSessions.length === 0) {
-            return false;
-        }
-        const shouldConfirmOnExit = this.configurationService.getValue('debug').confirmOnExit;
-        if (shouldConfirmOnExit === 'never') {
-            return false;
-        }
-        return this.showWindowCloseConfirmation(rootSessions.length);
-    }
-    async showWindowCloseConfirmation(numSessions) {
-        let message;
-        if (numSessions === 1) {
-            message = ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugLifecycle',
-                'debug.debugSessionCloseConfirmationSingular',
-                "There is an active debug session, are you sure you want to stop it?"
-            ));
-        }
-        else {
-            message = ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugLifecycle',
-                'debug.debugSessionCloseConfirmationPlural',
-                "There are active debug sessions, are you sure you want to stop them?"
-            ));
-        }
-        const res = await this.dialogService.confirm({
-            message,
-            type: 'warning',
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugLifecycle',
-                { key: 'debug.stop', comment: ['&& denotes a mnemonic'] },
-                "&&Stop Debugging"
-            ))
-        });
-        return !res.confirmed;
-    }
-};
-DebugLifecycle = ( __decorate([
-    ( __param(0, ILifecycleService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IDialogService))
-], DebugLifecycle));
-export { DebugLifecycle };

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

@@ -1,458 +0,0 @@
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { launchSchemaId } from '../../../services/configuration/common/configuration.js';
-import { inputsSchema } from '../../../services/configurationResolver/common/configurationResolverSchema.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { Extensions } from '../../../services/extensionManagement/common/extensionFeatures.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'debuggers',
-    defaultExtensionKind: ['workspace'],
-    jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/debug/common/debugSchemas',
-            '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: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.type',
-                        "Unique identifier for this debug adapter."
-                    )),
-                    type: 'string'
-                },
-                label: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.label',
-                        "Display name for this debug adapter."
-                    )),
-                    type: 'string'
-                },
-                program: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        '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: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.args',
-                        "Optional arguments to pass to the adapter."
-                    )),
-                    type: 'array'
-                },
-                runtime: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.runtime',
-                        "Optional runtime in case the program attribute is not an executable but requires a runtime."
-                    )),
-                    type: 'string'
-                },
-                runtimeArgs: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.runtimeArgs',
-                        "Optional runtime arguments."
-                    )),
-                    type: 'array'
-                },
-                variables: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.variables',
-                        "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
-                    )),
-                    type: 'object'
-                },
-                initialConfigurations: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.initialConfigurations',
-                        "Configurations for generating the initial \'launch.json\'."
-                    )),
-                    type: ['array', 'string'],
-                },
-                languages: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.languages',
-                        "List of languages for which the debug extension could be considered the \"default debugger\"."
-                    )),
-                    type: 'array'
-                },
-                configurationSnippets: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.configurationSnippets',
-                        "Snippets for adding new configurations in \'launch.json\'."
-                    )),
-                    type: 'array'
-                },
-                configurationAttributes: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.configurationAttributes',
-                        "JSON schema configurations for validating \'launch.json\'."
-                    )),
-                    type: 'object'
-                },
-                when: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        '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: ''
-                },
-                hiddenWhen: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.hiddenWhen',
-                        "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."
-                    )),
-                    type: 'string',
-                    default: ''
-                },
-                deprecated: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.deprecated',
-                        "Optional message to mark this debug type as being deprecated."
-                    )),
-                    type: 'string',
-                    default: ''
-                },
-                windows: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.windows',
-                        "Windows specific settings."
-                    )),
-                    type: 'object',
-                    properties: {
-                        runtime: {
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/debug/common/debugSchemas',
-                                'vscode.extension.contributes.debuggers.windows.runtime',
-                                "Runtime used for Windows."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                },
-                osx: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.osx',
-                        "macOS specific settings."
-                    )),
-                    type: 'object',
-                    properties: {
-                        runtime: {
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/debug/common/debugSchemas',
-                                'vscode.extension.contributes.debuggers.osx.runtime',
-                                "Runtime used for macOS."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                },
-                linux: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.linux',
-                        "Linux specific settings."
-                    )),
-                    type: 'object',
-                    properties: {
-                        runtime: {
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/debug/common/debugSchemas',
-                                'vscode.extension.contributes.debuggers.linux.runtime',
-                                "Runtime used for Linux."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                },
-                strings: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.debuggers.strings',
-                        "UI strings contributed by this debug adapter."
-                    )),
-                    type: 'object',
-                    properties: {
-                        unverifiedBreakpoints: {
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/debug/common/debugSchemas',
-                                '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: ( localizeWithPath(
-            'vs/workbench/contrib/debug/common/debugSchemas',
-            'vscode.extension.contributes.breakpoints',
-            'Contributes breakpoints.'
-        )),
-        type: 'array',
-        defaultSnippets: [{ body: [{ language: '' }] }],
-        items: {
-            type: 'object',
-            additionalProperties: false,
-            defaultSnippets: [{ body: { language: '' } }],
-            properties: {
-                language: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        'vscode.extension.contributes.breakpoints.language',
-                        "Allow breakpoints for this language."
-                    )),
-                    type: 'string'
-                },
-                when: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/debug/common/debugSchemas',
-                        '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: ( localizeWithPath(
-        'vs/workbench/contrib/debug/common/debugSchemas',
-        '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: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugSchemas',
-                'presentation.hidden',
-                "Controls if this configuration should be shown in the configuration dropdown and the command palette."
-            ))
-        },
-        group: {
-            type: 'string',
-            default: '',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugSchemas',
-                '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: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugSchemas',
-                '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: ( localizeWithPath(
-        'vs/workbench/contrib/debug/common/debugSchemas',
-        'app.launch.json.title',
-        "Launch"
-    )),
-    allowTrailingCommas: true,
-    allowComments: true,
-    required: [],
-    default: { version: '0.2.0', configurations: [], compounds: [] },
-    properties: {
-        version: {
-            type: 'string',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugSchemas',
-                'app.launch.json.version',
-                "Version of this file format."
-            )),
-            default: '0.2.0'
-        },
-        configurations: {
-            type: 'array',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugSchemas',
-                '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: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugSchemas',
-                '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: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugSchemas',
-                            '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: ( localizeWithPath(
-                                        'vs/workbench/contrib/debug/common/debugSchemas',
-                                        'useUniqueNames',
-                                        "Please use unique configuration names."
-                                    ))
-                                }, {
-                                    type: 'object',
-                                    required: ['name'],
-                                    properties: {
-                                        name: {
-                                            enum: [],
-                                            description: ( localizeWithPath(
-                                                'vs/workbench/contrib/debug/common/debugSchemas',
-                                                'app.launch.json.compound.name',
-                                                "Name of compound. Appears in the launch configuration drop down menu."
-                                            ))
-                                        },
-                                        folder: {
-                                            enum: [],
-                                            description: ( localizeWithPath(
-                                                'vs/workbench/contrib/debug/common/debugSchemas',
-                                                'app.launch.json.compound.folder',
-                                                "Name of folder in which the compound is located."
-                                            ))
-                                        }
-                                    }
-                                }]
-                        },
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugSchemas',
-                            'app.launch.json.compounds.configurations',
-                            "Names of configurations that will be started as part of this compound."
-                        ))
-                    },
-                    stopAll: {
-                        type: 'boolean',
-                        default: false,
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugSchemas',
-                            'app.launch.json.compound.stopAll',
-                            "Controls whether manually terminating one session will stop all of the compound sessions."
-                        ))
-                    },
-                    preLaunchTask: {
-                        type: 'string',
-                        default: '',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugSchemas',
-                            'compoundPrelaunchTask',
-                            "Task to run before any of the compound configurations start."
-                        ))
-                    }
-                },
-                default: defaultCompound
-            },
-            default: [
-                defaultCompound
-            ]
-        },
-        inputs: inputsSchema.definitions.inputs
-    }
-};
-class DebuggersDataRenderer extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.type = 'table';
-    }
-    shouldRender(manifest) {
-        return !!manifest.contributes?.debuggers;
-    }
-    render(manifest) {
-        const contrib = manifest.contributes?.debuggers || [];
-        if (!contrib.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
-        }
-        const headers = [
-            ( localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'debugger name', "Name")),
-            ( localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'debugger type', "Type")),
-        ];
-        const rows = ( contrib.map(d => {
-            return [
-                d.label ?? '',
-                d.type
-            ];
-        }));
-        return {
-            data: {
-                headers,
-                rows
-            },
-            dispose: () => { }
-        };
-    }
-}
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'debuggers',
-    label: ( localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'debuggers', "Debuggers")),
-    access: {
-        canToggle: false
-    },
-    renderer: ( new SyncDescriptor(DebuggersDataRenderer)),
-});
-export { breakpointsExtPoint, debuggersExtPoint, launchSchema, presentationSchema };