@codingame/monaco-vscode-api 3.2.2 → 4.0.0

package/vscode/src/vs/workbench/api/common/extHostQuickOpen.js

@@ -3,10 +3,10 @@ import { Emitter } from '../../../base/common/event.js';
 import { dispose } from '../../../base/common/lifecycle.js';
 import { MainContext } from './extHost.protocol.js';
 import { URI } from '../../../base/common/uri.js';
-import { QuickPickItemKind, InputBoxValidationSeverity, QuickInputButtons, ThemeIcon as ThemeIcon$1 } from './extHostTypes.js';
+import { QuickInputButtons, QuickPickItemKind, ThemeIcon as ThemeIcon$1, InputBoxValidationSeverity } from './extHostTypes.js';
 import { isCancellationError } from '../../../base/common/errors.js';
 import { coalesce } from '../../../base/common/arrays.js';
-import Severity from '../../../base/common/severity.js';
+import Severity$1 from '../../../base/common/severity.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
 import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MarkdownString } from './extHostTypeConverters.js';
@@ -114,16 +114,16 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             let severity;
             switch (result.severity) {
                 case InputBoxValidationSeverity.Info:
-                    severity = Severity.Info;
+                    severity = Severity$1.Info;
                     break;
                 case InputBoxValidationSeverity.Warning:
-                    severity = Severity.Warning;
+                    severity = Severity$1.Warning;
                     break;
                 case InputBoxValidationSeverity.Error:
-                    severity = Severity.Error;
+                    severity = Severity$1.Error;
                     break;
                 default:
-                    severity = result.message ? Severity.Error : Severity.Ignore;
+                    severity = result.message ? Severity$1.Error : Severity$1.Ignore;
                     break;
             }
             return {
@@ -571,13 +571,13 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
         set validationMessage(validationMessage) {
             this._validationMessage = validationMessage;
             if (!validationMessage) {
-                this.update({ validationMessage: undefined, severity: Severity.Ignore });
+                this.update({ validationMessage: undefined, severity: Severity$1.Ignore });
             }
             else if (typeof validationMessage === 'string') {
-                this.update({ validationMessage, severity: Severity.Error });
+                this.update({ validationMessage, severity: Severity$1.Error });
             }
             else {
-                this.update({ validationMessage: validationMessage.message, severity: validationMessage.severity ?? Severity.Error });
+                this.update({ validationMessage: validationMessage.message, severity: validationMessage.severity ?? Severity$1.Error });
             }
         }
     }

package/vscode/src/vs/workbench/api/common/extHostSCM.js

@@ -5,7 +5,7 @@ import { debounce } from '../../../base/common/decorators.js';
 import { DisposableStore, MutableDisposable } from '../../../base/common/lifecycle.js';
 import { asPromise } from '../../../base/common/async.js';
 import { MainContext } from './extHost.protocol.js';
-import { equals, sortedDiff } from '../../../base/common/arrays.js';
+import { sortedDiff, equals } from '../../../base/common/arrays.js';
 import { comparePaths } from '../../../base/common/comparers.js';
 import { ILogService } from '../../../platform/log/common/log.js';
 import { ExtensionIdentifierMap } from '../../../platform/extensions/common/extensions.js';

package/vscode/src/vs/workbench/api/common/extHostSearch.js

@@ -18,6 +18,8 @@ let ExtHostSearch = class ExtHostSearch {
         this._handlePool = 0;
         this._textSearchProvider = ( new Map());
         this._textSearchUsedSchemes = ( new Set());
+        this._aiTextSearchProvider = ( new Map());
+        this._aiTextSearchUsedSchemes = ( new Set());
         this._fileSearchProvider = ( new Map());
         this._fileSearchUsedSchemes = ( new Set());
         this._fileSearchManager = ( new FileSearchManager());
@@ -39,6 +41,20 @@ let ExtHostSearch = class ExtHostSearch {
             this._proxy.$unregisterProvider(handle);
         });
     }
+    registerAITextSearchProvider(scheme, provider) {
+        if (( this._aiTextSearchUsedSchemes.has(scheme))) {
+            throw new Error(`an AI text search provider for the scheme '${scheme}'is already registered`);
+        }
+        this._aiTextSearchUsedSchemes.add(scheme);
+        const handle = this._handlePool++;
+        this._aiTextSearchProvider.set(handle, provider);
+        this._proxy.$registerAITextSearchProvider(handle, this._transformScheme(scheme));
+        return toDisposable(() => {
+            this._aiTextSearchUsedSchemes.delete(scheme);
+            this._aiTextSearchProvider.delete(handle);
+            this._proxy.$unregisterProvider(handle);
+        });
+    }
     registerFileSearchProvider(scheme, provider) {
         if (( this._fileSearchUsedSchemes.has(scheme))) {
             throw new Error(`a file search provider for the scheme '${scheme}' is already registered`);
@@ -62,7 +78,7 @@ let ExtHostSearch = class ExtHostSearch {
             }, token);
         }
         else {
-            throw new Error('unknown provider: ' + handle);
+            throw new Error('3 unknown provider: ' + handle);
         }
     }
     async doInternalFileSearchWithCustomCallback(query, token, handleFileMatch) {
@@ -75,19 +91,34 @@ let ExtHostSearch = class ExtHostSearch {
     $provideTextSearchResults(handle, session, rawQuery, token) {
         const provider = this._textSearchProvider.get(handle);
         if (!provider || !provider.provideTextSearchResults) {
-            throw new Error(`Unknown provider ${handle}`);
+            throw new Error(`2 Unknown provider ${handle}`);
         }
         const query = reviveQuery(rawQuery);
         const engine = this.createTextSearchManager(query, provider);
         return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token);
     }
+    $provideAITextSearchResults(handle, session, rawQuery, token) {
+        const provider = this._aiTextSearchProvider.get(handle);
+        if (!provider || !provider.provideAITextSearchResults) {
+            throw new Error(`1 Unknown provider ${handle}`);
+        }
+        const query = reviveQuery(rawQuery);
+        const engine = this.createAITextSearchManager(query, provider);
+        return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token);
+    }
     $enableExtensionHostSearch() { }
     createTextSearchManager(query, provider) {
-        return ( new TextSearchManager(query, provider, {
+        return ( new TextSearchManager({ query, provider }, {
             readdir: resource => Promise.resolve([]),
             toCanonicalName: encoding => encoding
         }, 'textSearchProvider'));
     }
+    createAITextSearchManager(query, provider) {
+        return ( new TextSearchManager({ query, provider }, {
+            readdir: resource => Promise.resolve([]),
+            toCanonicalName: encoding => encoding
+        }, 'aiTextSearchProvider'));
+    }
 };
 ExtHostSearch = ( __decorate([
     ( __param(0, IExtHostRpcService)),

package/vscode/src/vs/workbench/api/common/extHostStatusBar.js

@@ -1,4 +1,4 @@
-import { Disposable, ThemeColor, asStatusBarItemIdentifier, StatusBarAlignment } from './extHostTypes.js';
+import { ThemeColor, asStatusBarItemIdentifier, StatusBarAlignment, Disposable } from './extHostTypes.js';
 import { MainContext } from './extHost.protocol.js';
 import { localizeWithPath } from '../../../nls.js';
 import { DisposableStore } from '../../../base/common/lifecycle.js';

package/vscode/src/vs/workbench/api/common/extHostTask.js

@@ -16,6 +16,7 @@ import { Schemas } from '../../../base/common/network.js';
 import { PlatformToString } from '../../../base/common/platform.js';
 import { ILogService } from '../../../platform/log/common/log.js';
 import { IExtHostApiDeprecationService } from './extHostApiDeprecationService.js';
+import '../../contrib/tasks/common/tasks.js';
 import { NotSupportedError, ErrorNoTelemetry } from '../../../base/common/errors.js';
 var TaskDefinitionDTO;
 ( (function(TaskDefinitionDTO) {

package/vscode/src/vs/workbench/api/common/extHostTerminalService.js

@@ -17,8 +17,9 @@ import { Promises } from '../../../base/common/async.js';
 import { TerminalQuickFix, ViewColumn } from './extHostTypeConverters.js';
 import { IExtHostCommands } from './extHostCommands.js';
 const IExtHostTerminalService = ( createDecorator('IExtHostTerminalService'));
-class ExtHostTerminal {
+class ExtHostTerminal extends Disposable {
     constructor(_proxy, _id, _creationOptions, _name) {
+        super();
         this._proxy = _proxy;
         this._id = _id;
         this._creationOptions = _creationOptions;
@@ -26,6 +27,8 @@ class ExtHostTerminal {
         this._disposed = false;
         this._state = { isInteractedWith: false };
         this.isOpen = false;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
         this._creationOptions = ( Object.freeze(this._creationOptions));
         this._pidPromise = ( new Promise(c => this._pidPromiseComplete = c));
         const that = this;
@@ -48,6 +51,9 @@ class ExtHostTerminal {
             get selection() {
                 return that._selection;
             },
+            get shellIntegration() {
+                return that.shellIntegration;
+            },
             sendText(text, shouldExecute = true) {
                 that._checkDisposed();
                 that._proxy.$sendText(that._id, text, shouldExecute);
@@ -77,6 +83,10 @@ class ExtHostTerminal {
             }
         };
     }
+    dispose() {
+        this._onWillDispose.fire();
+        super.dispose();
+    }
     async create(options, internalOptions) {
         if (typeof this._id !== 'string') {
             throw new Error('Terminal has already been created');
@@ -92,6 +102,7 @@ class ExtHostTerminal {
             initialText: options.message ?? undefined,
             strictEnv: options.strictEnv ?? undefined,
             hideFromUser: options.hideFromUser ?? undefined,
+            forceShellIntegration: internalOptions?.forceShellIntegration ?? undefined,
             isFeatureTerminal: internalOptions?.isFeatureTerminal ?? undefined,
             isExtensionOwnedTerminal: true,
             useShellEnvironment: internalOptions?.useShellEnvironment ?? undefined,
@@ -288,7 +299,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
             processArgument: arg => {
                 const deserialize = (arg) => {
                     const cast = arg;
-                    return this._getTerminalById(cast.instanceId)?.value;
+                    return this.getTerminalById(cast.instanceId)?.value;
                 };
                 switch (arg?.$mid) {
                     case 15 : return deserialize(arg);
@@ -354,7 +365,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         return internalOptions;
     }
     attachPtyToTerminal(id, pty) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (!terminal) {
             throw new Error(`Cannot resolve terminal with id ${id} for virtual process`);
         }
@@ -371,7 +382,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
             }
             return;
         }
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (terminal) {
             this._activeTerminal = terminal;
             if (original !== this._activeTerminal) {
@@ -380,13 +391,13 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         }
     }
     async $acceptTerminalProcessData(id, data) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (terminal) {
             this._onDidWriteTerminalData.fire({ terminal: terminal.value, data });
         }
     }
     async $acceptTerminalDimensions(id, cols, rows) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (terminal) {
             if (terminal.setDimensions(cols, rows)) {
                 this._onDidChangeTerminalDimensions.fire({
@@ -397,7 +408,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         }
     }
     async $acceptDidExecuteCommand(id, command) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (terminal) {
             this._onDidExecuteCommand.fire({ terminal: terminal.value, ...command });
         }
@@ -406,7 +417,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         this._terminalProcesses.get(id)?.resize(cols, rows);
     }
     async $acceptTerminalTitleChange(id, name) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (terminal) {
             terminal.name = name;
         }
@@ -443,11 +454,11 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         terminal.isOpen = true;
     }
     async $acceptTerminalProcessId(id, processId) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         terminal?._setProcessId(processId);
     }
     async $startExtensionTerminal(id, initialDimensions) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (!terminal) {
             return { message: ( localizeWithPath(
                 'vs/workbench/api/common/extHostTerminalService',
@@ -496,13 +507,13 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         this._terminalProcesses.get(id)?.input(data);
     }
     $acceptTerminalInteraction(id) {
-        const terminal = this._getTerminalById(id);
+        const terminal = this.getTerminalById(id);
         if (terminal?.setInteractedWith()) {
             this._onDidChangeTerminalState.fire(terminal.value);
         }
     }
     $acceptTerminalSelection(id, selection) {
-        this._getTerminalById(id)?.setSelection(selection);
+        this.getTerminalById(id)?.setSelection(selection);
     }
     $acceptProcessResize(id, cols, rows) {
         try {
@@ -606,7 +617,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         this.createTerminalFromOptions(profile.options, options);
     }
     async $provideLinks(terminalId, line) {
-        const terminal = this._getTerminalById(terminalId);
+        const terminal = this.getTerminalById(terminalId);
         if (!terminal) {
             return [];
         }
@@ -670,9 +681,15 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         }
         this._proxy.$sendProcessExit(id, exitCode);
     }
-    _getTerminalById(id) {
+    getTerminalById(id) {
         return this._getTerminalObjectById(this._terminals, id);
     }
+    getTerminalIdByApiObject(terminal) {
+        const index = this._terminals.findIndex(item => {
+            return item.value === terminal;
+        });
+        return index >= 0 ? index : null;
+    }
     _getTerminalObjectById(array, id) {
         const index = this._getTerminalObjectIndexById(array, id);
         return index !== null ? array[index] : null;
@@ -681,10 +698,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         const index = array.findIndex(item => {
             return item._id === id;
         });
-        if (index === -1) {
-            return null;
-        }
-        return index;
+        return index >= 0 ? index : null;
     }
     getEnvironmentVariableCollection(extension) {
         let collection = this._environmentVariableCollections.get(extension.identifier.value);

package/vscode/src/vs/workbench/api/common/extHostTerminalShellIntegration.js

@@ -0,0 +1,214 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { MainContext } from './extHost.protocol.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IExtHostTerminalService } from './extHostTerminalService.js';
+import { Emitter } from '../../../base/common/event.js';
+import { URI } from '../../../base/common/uri.js';
+import { AsyncIterableObject, Barrier } from '../../../base/common/async.js';
+const IExtHostTerminalShellIntegration = ( createDecorator('IExtHostTerminalShellIntegration'));
+let ExtHostTerminalShellIntegration = class ExtHostTerminalShellIntegration extends Disposable {
+    constructor(extHostRpc, _extHostTerminalService) {
+        super();
+        this._extHostTerminalService = _extHostTerminalService;
+        this._activeShellIntegrations = ( new Map());
+        this._onDidChangeTerminalShellIntegration = ( new Emitter());
+        this.onDidChangeTerminalShellIntegration = this._onDidChangeTerminalShellIntegration.event;
+        this._onDidStartTerminalShellExecution = ( new Emitter());
+        this.onDidStartTerminalShellExecution = this._onDidStartTerminalShellExecution.event;
+        this._onDidEndTerminalShellExecution = ( new Emitter());
+        this.onDidEndTerminalShellExecution = this._onDidEndTerminalShellExecution.event;
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadTerminalShellIntegration));
+        this._register(toDisposable(() => {
+            for (const [_, integration] of this._activeShellIntegrations) {
+                integration.dispose();
+            }
+            this._activeShellIntegrations.clear();
+        }));
+    }
+    $shellIntegrationChange(instanceId) {
+        const terminal = this._extHostTerminalService.getTerminalById(instanceId);
+        if (!terminal) {
+            return;
+        }
+        const apiTerminal = terminal.value;
+        let shellIntegration = this._activeShellIntegrations.get(instanceId);
+        if (!shellIntegration) {
+            shellIntegration = ( new InternalTerminalShellIntegration(terminal.value, this._onDidStartTerminalShellExecution));
+            this._activeShellIntegrations.set(instanceId, shellIntegration);
+            shellIntegration.store.add(terminal.onWillDispose(() => this._activeShellIntegrations.get(instanceId)?.dispose()));
+            shellIntegration.store.add(shellIntegration.onDidRequestShellExecution(commandLine => this._proxy.$executeCommand(instanceId, commandLine)));
+            shellIntegration.store.add(shellIntegration.onDidRequestEndExecution(e => this._onDidEndTerminalShellExecution.fire(e.value)));
+            shellIntegration.store.add(shellIntegration.onDidRequestChangeShellIntegration(e => this._onDidChangeTerminalShellIntegration.fire(e)));
+            terminal.shellIntegration = shellIntegration.value;
+        }
+        this._onDidChangeTerminalShellIntegration.fire({
+            terminal: apiTerminal,
+            shellIntegration: shellIntegration.value
+        });
+    }
+    $shellExecutionStart(instanceId, commandLine, cwd) {
+        if (!( this._activeShellIntegrations.has(instanceId))) {
+            this.$shellIntegrationChange(instanceId);
+        }
+        this._activeShellIntegrations.get(instanceId)?.startShellExecution(commandLine, cwd);
+    }
+    $shellExecutionEnd(instanceId, commandLine, exitCode) {
+        this._activeShellIntegrations.get(instanceId)?.endShellExecution(commandLine, exitCode);
+    }
+    $shellExecutionData(instanceId, data) {
+        this._activeShellIntegrations.get(instanceId)?.emitData(data);
+    }
+    $cwdChange(instanceId, cwd) {
+        this._activeShellIntegrations.get(instanceId)?.setCwd(cwd);
+    }
+    $closeTerminal(instanceId) {
+        this._activeShellIntegrations.get(instanceId)?.dispose();
+        this._activeShellIntegrations.delete(instanceId);
+    }
+};
+ExtHostTerminalShellIntegration = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostTerminalService))
+], ExtHostTerminalShellIntegration));
+class InternalTerminalShellIntegration extends Disposable {
+    get currentExecution() { return this._currentExecution; }
+    constructor(_terminal, _onDidStartTerminalShellExecution) {
+        super();
+        this._terminal = _terminal;
+        this._onDidStartTerminalShellExecution = _onDidStartTerminalShellExecution;
+        this._ignoreNextExecution = false;
+        this.store = this._register(( new DisposableStore()));
+        this._onDidRequestChangeShellIntegration = this._register(( new Emitter()));
+        this.onDidRequestChangeShellIntegration = this._onDidRequestChangeShellIntegration.event;
+        this._onDidRequestShellExecution = this._register(( new Emitter()));
+        this.onDidRequestShellExecution = this._onDidRequestShellExecution.event;
+        this._onDidRequestEndExecution = this._register(( new Emitter()));
+        this.onDidRequestEndExecution = this._onDidRequestEndExecution.event;
+        const that = this;
+        this.value = {
+            get cwd() {
+                return that._cwd;
+            },
+            executeCommand(commandLine) {
+                that._onDidRequestShellExecution.fire(commandLine);
+                const execution = that.startShellExecution(commandLine, that._cwd).value;
+                that._ignoreNextExecution = true;
+                return execution;
+            }
+        };
+    }
+    startShellExecution(commandLine, cwd) {
+        if (this._ignoreNextExecution && this._currentExecution) {
+            this._ignoreNextExecution = false;
+        }
+        else {
+            if (this._currentExecution) {
+                this._currentExecution.endExecution(undefined, undefined);
+                this._onDidRequestEndExecution.fire(this._currentExecution);
+            }
+            this._currentExecution = ( new InternalTerminalShellExecution(this._terminal, commandLine, cwd));
+            this._onDidStartTerminalShellExecution.fire(this._currentExecution.value);
+        }
+        return this._currentExecution;
+    }
+    emitData(data) {
+        this.currentExecution?.emitData(data);
+    }
+    endShellExecution(commandLine, exitCode) {
+        if (this._currentExecution) {
+            this._currentExecution.endExecution(commandLine, exitCode);
+            this._onDidRequestEndExecution.fire(this._currentExecution);
+            this._currentExecution = undefined;
+        }
+    }
+    setCwd(cwd) {
+        let wasChanged = false;
+        if (URI.isUri(this._cwd)) {
+            if (( this._cwd.toString()) !== ( cwd.toString())) {
+                wasChanged = true;
+            }
+        }
+        else if (this._cwd !== cwd) {
+            wasChanged = true;
+        }
+        if (wasChanged) {
+            this._cwd = cwd;
+            this._onDidRequestChangeShellIntegration.fire({ terminal: this._terminal, shellIntegration: this.value });
+        }
+    }
+}
+class InternalTerminalShellExecution {
+    constructor(terminal, _commandLine, cwd) {
+        this.terminal = terminal;
+        this._commandLine = _commandLine;
+        this.cwd = cwd;
+        this._exitCode = ( new Promise(resolve => {
+            this._exitCodeResolve = resolve;
+        }));
+        const that = this;
+        this.value = {
+            get terminal() {
+                return terminal;
+            },
+            get commandLine() {
+                return that._commandLine;
+            },
+            get cwd() {
+                return cwd;
+            },
+            get exitCode() {
+                return that._exitCode;
+            },
+            createDataStream() {
+                return that._createDataStream();
+            }
+        };
+    }
+    _createDataStream() {
+        if (!this._dataStream) {
+            if (this._exitCodeResolve === undefined) {
+                return AsyncIterableObject.EMPTY;
+            }
+            this._dataStream = ( new ShellExecutionDataStream());
+        }
+        return this._dataStream.createIterable();
+    }
+    emitData(data) {
+        this._dataStream?.emitData(data);
+    }
+    endExecution(commandLine, exitCode) {
+        if (commandLine) {
+            this._commandLine = commandLine;
+        }
+        this._dataStream?.endExecution();
+        this._dataStream = undefined;
+        this._exitCodeResolve?.(exitCode);
+        this._exitCodeResolve = undefined;
+    }
+}
+class ShellExecutionDataStream extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._emitters = [];
+    }
+    createIterable() {
+        const barrier = this._barrier = ( new Barrier());
+        const iterable = ( new AsyncIterableObject(async (emitter) => {
+            this._emitters.push(emitter);
+            await barrier.wait();
+        }));
+        return iterable;
+    }
+    emitData(data) {
+        for (const emitter of this._emitters) {
+            emitter.emitOne(data);
+        }
+    }
+    endExecution() {
+        this._barrier?.open();
+        this._barrier = undefined;
+    }
+}
+export { ExtHostTerminalShellIntegration, IExtHostTerminalShellIntegration };