@codingame/monaco-vscode-api 1.85.1 → 1.85.3

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProcessExtHostProxy.js

@@ -0,0 +1,130 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITerminalService } from './terminal.js';
+let TerminalProcessExtHostProxy = class TerminalProcessExtHostProxy extends Disposable {
+    get onProcessReady() { return this._onProcessReady.event; }
+    constructor(instanceId, _cols, _rows, _terminalService) {
+        super();
+        this.instanceId = instanceId;
+        this._cols = _cols;
+        this._rows = _rows;
+        this._terminalService = _terminalService;
+        this.id = 0;
+        this.shouldPersist = false;
+        this._onProcessData = this._register(( new Emitter()));
+        this.onProcessData = this._onProcessData.event;
+        this._onProcessReady = this._register(( new Emitter()));
+        this._onStart = this._register(( new Emitter()));
+        this.onStart = this._onStart.event;
+        this._onInput = this._register(( new Emitter()));
+        this.onInput = this._onInput.event;
+        this._onBinary = this._register(( new Emitter()));
+        this.onBinary = this._onBinary.event;
+        this._onResize = this._register(( new Emitter()));
+        this.onResize = this._onResize.event;
+        this._onAcknowledgeDataEvent = this._register(( new Emitter()));
+        this.onAcknowledgeDataEvent = this._onAcknowledgeDataEvent.event;
+        this._onShutdown = this._register(( new Emitter()));
+        this.onShutdown = this._onShutdown.event;
+        this._onRequestInitialCwd = this._register(( new Emitter()));
+        this.onRequestInitialCwd = this._onRequestInitialCwd.event;
+        this._onRequestCwd = this._register(( new Emitter()));
+        this.onRequestCwd = this._onRequestCwd.event;
+        this._onDidChangeProperty = this._register(( new Emitter()));
+        this.onDidChangeProperty = this._onDidChangeProperty.event;
+        this._onProcessExit = this._register(( new Emitter()));
+        this.onProcessExit = this._onProcessExit.event;
+        this._pendingInitialCwdRequests = [];
+        this._pendingCwdRequests = [];
+    }
+    emitData(data) {
+        this._onProcessData.fire(data);
+    }
+    emitTitle(title) {
+        this._onDidChangeProperty.fire({ type: "title" , value: title });
+    }
+    emitReady(pid, cwd) {
+        this._onProcessReady.fire({ pid, cwd, windowsPty: undefined });
+    }
+    emitProcessProperty({ type, value }) {
+        switch (type) {
+            case "cwd" :
+                this.emitCwd(value);
+                break;
+            case "initialCwd" :
+                this.emitInitialCwd(value);
+                break;
+            case "title" :
+                this.emitTitle(value);
+                break;
+            case "overrideDimensions" :
+                this.emitOverrideDimensions(value);
+                break;
+            case "resolvedShellLaunchConfig" :
+                this.emitResolvedShellLaunchConfig(value);
+                break;
+        }
+    }
+    emitExit(exitCode) {
+        this._onProcessExit.fire(exitCode);
+        this.dispose();
+    }
+    emitOverrideDimensions(dimensions) {
+        this._onDidChangeProperty.fire({ type: "overrideDimensions" , value: dimensions });
+    }
+    emitResolvedShellLaunchConfig(shellLaunchConfig) {
+        this._onDidChangeProperty.fire({ type: "resolvedShellLaunchConfig" , value: shellLaunchConfig });
+    }
+    emitInitialCwd(initialCwd) {
+        while (this._pendingInitialCwdRequests.length > 0) {
+            this._pendingInitialCwdRequests.pop()(initialCwd);
+        }
+    }
+    emitCwd(cwd) {
+        while (this._pendingCwdRequests.length > 0) {
+            this._pendingCwdRequests.pop()(cwd);
+        }
+    }
+    async start() {
+        return this._terminalService.requestStartExtensionTerminal(this, this._cols, this._rows);
+    }
+    shutdown(immediate) {
+        this._onShutdown.fire(immediate);
+    }
+    input(data) {
+        this._onInput.fire(data);
+    }
+    resize(cols, rows) {
+        this._onResize.fire({ cols, rows });
+    }
+    clearBuffer() {
+    }
+    acknowledgeDataEvent() {
+    }
+    async setUnicodeVersion(version) {
+    }
+    async processBinary(data) {
+        this._onBinary.fire(data);
+    }
+    getInitialCwd() {
+        return ( new Promise(resolve => {
+            this._onRequestInitialCwd.fire();
+            this._pendingInitialCwdRequests.push(resolve);
+        }));
+    }
+    getCwd() {
+        return ( new Promise(resolve => {
+            this._onRequestCwd.fire();
+            this._pendingCwdRequests.push(resolve);
+        }));
+    }
+    async refreshProperty(type) {
+    }
+    async updateProperty(type, value) {
+    }
+};
+TerminalProcessExtHostProxy = ( __decorate([
+    ( __param(3, ITerminalService))
+], TerminalProcessExtHostProxy));
+export { TerminalProcessExtHostProxy };

package/vscode/src/vs/workbench/contrib/timeline/common/timeline.js

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const TimelinePaneId = 'timeline';
 const TIMELINE_SERVICE_ID = 'timeline';
 const ITimelineService = ( createDecorator(TIMELINE_SERVICE_ID));
-export { ITimelineService };
+export { ITimelineService, TimelinePaneId };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -3,6 +3,7 @@ import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
@@ -56,6 +57,24 @@ function addAccountUsage(storageService, providerId, accountName, extensionId, e
     }
     storageService.store(accountKey, JSON.stringify(usages), -1 , 1 );
 }
+async function getCurrentAuthenticationSessionInfo(secretStorageService, productService) {
+    const authenticationSessionValue = await secretStorageService.get(`${productService.urlProtocol}.loginAccount`);
+    if (authenticationSessionValue) {
+        try {
+            const authenticationSessionInfo = JSON.parse(authenticationSessionValue);
+            if (authenticationSessionInfo
+                && isString(authenticationSessionInfo.id)
+                && isString(authenticationSessionInfo.accessToken)
+                && isString(authenticationSessionInfo.providerId)) {
+                return authenticationSessionInfo;
+            }
+        }
+        catch (e) {
+            console.error(`Failed parsing current auth session value: ${e}`);
+        }
+    }
+    return undefined;
+}
 function readAllowedExtensions(storageService, providerId, accountName) {
     let trustedExtensions = [];
     try {
@@ -660,4 +679,4 @@ AuthenticationService = ( __decorate([
     ( __param(4, IQuickInputService)),
     ( __param(5, IProductService))
 ], AuthenticationService));
-export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, readAccountUsages, readAllowedExtensions, removeAccountUsage };
+export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo, readAccountUsages, readAllowedExtensions, removeAccountUsage };

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

@@ -0,0 +1,205 @@
+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

@@ -0,0 +1,11 @@
+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 };

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

@@ -1,7 +1,7 @@
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as process from 'monaco-editor/esm/vs/base/common/process.js';
-import * as types from 'monaco-editor/esm/vs/base/common/types.js';
-import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as Objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import { isWindows, isMacintosh, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
@@ -42,7 +42,7 @@ class AbstractVariableResolverService {
         return this.recursiveResolve(environment, root ? root.uri : undefined, value);
     }
     async resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables) {
-        const result = objects.deepClone(config);
+        const result = Objects.deepClone(config);
         if (isWindows && result.windows) {
             ( Object.keys(result.windows)).forEach(key => result[key] = result.windows[key]);
         }
@@ -84,7 +84,7 @@ class AbstractVariableResolverService {
         }
     }
     async recursiveResolve(environment, folderUri, value, commandValueMapping, resolvedVariables) {
-        if (types.isString(value)) {
+        if (Types.isString(value)) {
             return this.resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables);
         }
         else if (Array.isArray(value)) {
@@ -92,7 +92,7 @@ class AbstractVariableResolverService {
                 s => this.recursiveResolve(environment, folderUri, s, commandValueMapping, resolvedVariables)
             )));
         }
-        else if (types.isObject(value)) {
+        else if (Types.isObject(value)) {
             const result = Object.create(null);
             const replaced = await Promise.all(( ( Object.keys(value)).map(async (key) => {
                 const replaced = await this.resolveString(environment, folderUri, key, commandValueMapping, resolvedVariables);
@@ -112,7 +112,7 @@ class AbstractVariableResolverService {
             }
             let resolvedValue = await this.evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping);
             resolvedVariables?.set(variable, resolvedValue);
-            if ((resolvedValue !== match) && types.isString(resolvedValue) && resolvedValue.match(AbstractVariableResolverService.VARIABLE_REGEXP)) {
+            if ((resolvedValue !== match) && Types.isString(resolvedValue) && resolvedValue.match(AbstractVariableResolverService.VARIABLE_REGEXP)) {
                 resolvedValue = await this.resolveString(environment, folderUri, resolvedValue, commandValueMapping, resolvedVariables);
             }
             return resolvedValue;
@@ -166,7 +166,7 @@ class AbstractVariableResolverService {
                 if (argument) {
                     if (environment.env) {
                         const env = environment.env[isWindows ? argument.toLowerCase() : argument];
-                        if (types.isString(env)) {
+                        if (Types.isString(env)) {
                             return env;
                         }
                     }
@@ -176,10 +176,10 @@ class AbstractVariableResolverService {
             case 'config':
                 if (argument) {
                     const config = this._context.getConfigurationValue(folderUri, argument);
-                    if (types.isUndefinedOrNull(config)) {
+                    if (Types.isUndefinedOrNull(config)) {
                         throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
                     }
-                    if (types.isObject(config)) {
+                    if (Types.isObject(config)) {
                         throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
                     }
                     return config;

package/vscode/src/vs/workbench/services/extensionManagement/browser/extensionBisect.js

@@ -393,4 +393,4 @@ registerAction2(class extends Action2 {
         hostService.reload();
     }
 });
-export { IExtensionBisectService };
+export { ExtensionBisectService, IExtensionBisectService };

package/vscode/src/vs/workbench/services/keybinding/common/keybindingEditing.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
 import * as json from 'monaco-editor/esm/vs/base/common/json.js';
-import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import * as Objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import { setProperty } from '../../../../base/common/jsonEdit.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
@@ -181,7 +181,7 @@ let KeybindingsEditingService = class KeybindingsEditingService extends Disposab
         if (whenA && whenB && !whenA.equals(whenB)) {
             return false;
         }
-        if (!objects.equals(a.args, b.args)) {
+        if (!Objects.equals(a.args, b.args)) {
             return false;
         }
         return true;

package/vscode/src/vs/workbench/services/languageStatus/common/languageStatusService.js

@@ -1,3 +1,26 @@
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const ILanguageStatusService = ( createDecorator('ILanguageStatusService'));
-export { ILanguageStatusService };
+class LanguageStatusServiceImpl {
+    constructor() {
+        this._provider = ( new LanguageFeatureRegistry());
+        this.onDidChange = this._provider.onDidChange;
+    }
+    addStatus(status) {
+        return this._provider.register(status.selector, status);
+    }
+    getLanguageStatus(model) {
+        return this._provider.ordered(model).sort((a, b) => {
+            let res = b.severity - a.severity;
+            if (res === 0) {
+                res = compare(a.source, b.source);
+            }
+            if (res === 0) {
+                res = compare(a.id, b.id);
+            }
+            return res;
+        });
+    }
+}
+export { ILanguageStatusService, LanguageStatusServiceImpl };

package/vscode/src/vs/workbench/services/preferences/browser/keybindingsEditorInput.js

@@ -0,0 +1,41 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { KeybindingsEditorModel } from './keybindingsEditorModel.js';
+var KeybindingsEditorInput_1;
+let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
+    static { KeybindingsEditorInput_1 = this; }
+    static { this.ID = 'workbench.input.keybindings'; }
+    constructor(instantiationService) {
+        super();
+        this.searchOptions = null;
+        this.resource = undefined;
+        this.keybindingsModel = instantiationService.createInstance(KeybindingsEditorModel, OS);
+    }
+    get typeId() {
+        return KeybindingsEditorInput_1.ID;
+    }
+    getName() {
+        return ( nls.localizeWithPath(
+            'vs/workbench/services/preferences/browser/keybindingsEditorInput',
+            'keybindingsInputName',
+            "Keyboard Shortcuts"
+        ));
+    }
+    async resolve() {
+        return this.keybindingsModel;
+    }
+    matches(otherInput) {
+        return otherInput instanceof KeybindingsEditorInput_1;
+    }
+    dispose() {
+        this.keybindingsModel.dispose();
+        super.dispose();
+    }
+};
+KeybindingsEditorInput = KeybindingsEditorInput_1 = ( __decorate([
+    ( __param(0, IInstantiationService))
+], KeybindingsEditorInput));
+export { KeybindingsEditorInput };