@codingame/monaco-vscode-debug-service-override 1.85.0 → 1.85.2

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

@@ -1,127 +0,0 @@
-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.localizeWithPath(
-    'vs/workbench/contrib/debug/common/debugSource',
-    '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/disassemblyViewInput.js

@@ -1,31 +0,0 @@
-import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
-import { localizeWithPath } 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 ( localizeWithPath(
-            'vs/workbench/contrib/debug/common/disassemblyViewInput',
-            'disassemblyInputName',
-            "Disassembly"
-        ));
-    }
-    matches(other) {
-        return other instanceof DisassemblyViewInput;
-    }
-}
-
-export { DisassemblyViewInput };

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverSchema.js

@@ -1,207 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-
-const idDescription = ( nls.localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.id',
-    "The input's id is used to associate an input with a variable of the form ${input:id}."
-));
-const typeDescription = ( nls.localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.type',
-    "The type of user input prompt to use."
-));
-const descriptionDescription = ( nls.localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.description',
-    "The description is shown when the user is prompted for input."
-));
-const defaultDescription = ( nls.localizeWithPath(
-    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-    'JsonSchema.input.default',
-    "The default value for the input."
-));
-const inputsSchema = {
-    definitions: {
-        inputs: {
-            type: 'array',
-            description: ( nls.localizeWithPath(
-                'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                'JsonSchema.inputs',
-                'User inputs. Used for defining user input prompts, such as free string input or a choice from several options.'
-            )),
-            items: {
-                oneOf: [
-                    {
-                        type: 'object',
-                        required: ['id', 'type', 'description'],
-                        additionalProperties: false,
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: idDescription
-                            },
-                            type: {
-                                type: 'string',
-                                description: typeDescription,
-                                enum: ['promptString'],
-                                enumDescriptions: [
-                                    ( nls.localizeWithPath(
-                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                        'JsonSchema.input.type.promptString',
-                                        "The 'promptString' type opens an input box to ask the user for input."
-                                    )),
-                                ]
-                            },
-                            description: {
-                                type: 'string',
-                                description: descriptionDescription
-                            },
-                            default: {
-                                type: 'string',
-                                description: defaultDescription
-                            },
-                            password: {
-                                type: 'boolean',
-                                description: ( nls.localizeWithPath(
-                                    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                    'JsonSchema.input.password',
-                                    "Controls if a password input is shown. Password input hides the typed text."
-                                )),
-                            },
-                        }
-                    },
-                    {
-                        type: 'object',
-                        required: ['id', 'type', 'description', 'options'],
-                        additionalProperties: false,
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: idDescription
-                            },
-                            type: {
-                                type: 'string',
-                                description: typeDescription,
-                                enum: ['pickString'],
-                                enumDescriptions: [
-                                    ( nls.localizeWithPath(
-                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                        'JsonSchema.input.type.pickString',
-                                        "The 'pickString' type shows a selection list."
-                                    )),
-                                ]
-                            },
-                            description: {
-                                type: 'string',
-                                description: descriptionDescription
-                            },
-                            default: {
-                                type: 'string',
-                                description: defaultDescription
-                            },
-                            options: {
-                                type: 'array',
-                                description: ( nls.localizeWithPath(
-                                    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                    'JsonSchema.input.options',
-                                    "An array of strings that defines the options for a quick pick."
-                                )),
-                                items: {
-                                    oneOf: [
-                                        {
-                                            type: 'string'
-                                        },
-                                        {
-                                            type: 'object',
-                                            required: ['value'],
-                                            additionalProperties: false,
-                                            properties: {
-                                                label: {
-                                                    type: 'string',
-                                                    description: ( nls.localizeWithPath(
-                                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                                        'JsonSchema.input.pickString.optionLabel',
-                                                        "Label for the option."
-                                                    ))
-                                                },
-                                                value: {
-                                                    type: 'string',
-                                                    description: ( nls.localizeWithPath(
-                                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                                        'JsonSchema.input.pickString.optionValue',
-                                                        "Value for the option."
-                                                    ))
-                                                }
-                                            }
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    },
-                    {
-                        type: 'object',
-                        required: ['id', 'type', 'command'],
-                        additionalProperties: false,
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: idDescription
-                            },
-                            type: {
-                                type: 'string',
-                                description: typeDescription,
-                                enum: ['command'],
-                                enumDescriptions: [
-                                    ( nls.localizeWithPath(
-                                        'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                        'JsonSchema.input.type.command',
-                                        "The 'command' type executes a command."
-                                    )),
-                                ]
-                            },
-                            command: {
-                                type: 'string',
-                                description: ( nls.localizeWithPath(
-                                    'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                    'JsonSchema.input.command.command',
-                                    "The command to execute for this input variable."
-                                ))
-                            },
-                            args: {
-                                oneOf: [
-                                    {
-                                        type: 'object',
-                                        description: ( nls.localizeWithPath(
-                                            'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
-                                    },
-                                    {
-                                        type: 'array',
-                                        description: ( nls.localizeWithPath(
-                                            'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
-                                    },
-                                    {
-                                        type: 'string',
-                                        description: ( nls.localizeWithPath(
-                                            'vs/workbench/services/configurationResolver/common/configurationResolverSchema',
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            }
-        }
-    }
-};
-
-export { inputsSchema };

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverUtils.js

@@ -1,13 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-
-function applyDeprecatedVariableMessage(schema) {
-    schema.pattern = schema.pattern || '^(?!.*\\$\\{(env|config|command)\\.)';
-    schema.patternErrorMessage = schema.patternErrorMessage ||
-        ( nls.localizeWithPath(
-         'vs/workbench/services/configurationResolver/common/configurationResolverUtils',
-         'deprecatedVariables',
-         "'env.', 'config.' and 'command.' are deprecated, use 'env:', 'config:' and 'command:' instead."
-        ));
-}
-
-export { applyDeprecatedVariableMessage };