@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

package/vscode/src/vs/platform/files/common/files.d.ts

@@ -198,10 +198,25 @@ interface IFileService {
     /**
      * Allows to start a watcher that reports file/folder change events on the provided resource.
      *
-     * Note: recursive file watching is not supported from this method. Only events from files
-     * that are direct children of the provided resource will be reported.
+     * The watcher runs correlated and thus, file events will be reported on the returned
+     * `IFileSystemWatcher` and not on the generic `IFileService.onDidFilesChange` event.
      */
-    watch(resource: URI, options?: IWatchOptions): IDisposable;
+    createWatcher(resource: URI, options: IWatchOptionsWithoutCorrelation): IFileSystemWatcher;
+    /**
+     * Allows to start a watcher that reports file/folder change events on the provided resource.
+     *
+     * The watcher runs correlated and thus, file events will be reported on the returned
+     * `IFileSystemWatcher` and not on the generic `IFileService.onDidFilesChange` event.
+     */
+    watch(resource: URI, options: IWatchOptionsWithCorrelation): IFileSystemWatcher;
+    /**
+     * Allows to start a watcher that reports file/folder change events on the provided resource.
+     *
+     * The watcher runs uncorrelated and thus will report all events from `IFileService.onDidFilesChange`.
+     * This means, most listeners in the application will receive your events. It is encouraged to
+     * use correlated watchers (via `IWatchOptionsWithCorrelation`) to limit events to your listener.
+    */
+    watch(resource: URI, options?: IWatchOptionsWithoutCorrelation): IDisposable;
     /**
      * Frees up any resources occupied by this service.
      */
@@ -396,12 +411,12 @@ interface IStat {
      */
     readonly permissions?: FilePermission;
 }
-interface IWatchOptions {
+interface IWatchOptionsWithoutCorrelation {
     /**
      * Set to `true` to watch for changes recursively in a folder
      * and all of its children.
      */
-    readonly recursive: boolean;
+    recursive: boolean;
     /**
      * A set of glob patterns or paths to exclude from watching.
      * Paths can be relative or absolute and when relative are
@@ -419,6 +434,25 @@ interface IWatchOptions {
      */
     includes?: Array<string | IRelativePattern>;
 }
+interface IWatchOptions extends IWatchOptionsWithoutCorrelation {
+    /**
+     * If provided, file change events from the watcher that
+     * are a result of this watch request will carry the same
+     * id.
+     */
+    readonly correlationId?: number;
+}
+interface IWatchOptionsWithCorrelation extends IWatchOptions {
+    readonly correlationId: number;
+}
+interface IFileSystemWatcher extends IDisposable {
+    /**
+     * An event which fires on file/folder change only for changes
+     * that correlate to the watch request with matching correlation
+     * identifier.
+     */
+    readonly onDidChange: Event<FileChangesEvent>;
+}
 declare const enum FileSystemProviderCapabilities {
     /**
      * No capabilities.
@@ -595,17 +629,27 @@ interface IFileChange {
     /**
      * The type of change that occurred to the file.
      */
-    readonly type: FileChangeType;
+    type: FileChangeType;
     /**
      * The unified resource identifier of the file that changed.
      */
     readonly resource: URI;
+    /**
+     * If provided when starting the file watcher, the correlation
+     * identifier will match the original file watching request as
+     * a way to identify the original component that is interested
+     * in the change.
+     */
+    readonly cId?: number;
 }
 declare class FileChangesEvent {
+    private readonly ignorePathCasing;
+    private static readonly MIXED_CORRELATION;
+    private readonly correlationId;
+    constructor(changes: readonly IFileChange[], ignorePathCasing: boolean);
     private readonly added;
     private readonly updated;
     private readonly deleted;
-    constructor(changes: readonly IFileChange[], ignorePathCasing: boolean);
     /**
      * Find out if the file change events match the provided resource.
      *
@@ -631,6 +675,26 @@ declare class FileChangesEvent {
      * Returns if this event contains updated files.
      */
     gotUpdated(): boolean;
+    /**
+     * Returns if this event contains changes that correlate to the
+     * provided `correlationId`.
+     *
+     * File change event correlation is an advanced watch feature that
+     * allows to  identify from which watch request the events originate
+     * from. This correlation allows to route events specifically
+     * only to the requestor and not emit them to all listeners.
+     */
+    correlates(correlationId: number): boolean;
+    /**
+     * Figure out if the event contains changes that correlate to one
+     * correlation identifier.
+     *
+     * File change event correlation is an advanced watch feature that
+     * allows to  identify from which watch request the events originate
+     * from. This correlation allows to route events specifically
+     * only to the requestor and not emit them to all listeners.
+     */
+    hasCorrelation(): boolean;
     /**
      * @deprecated use the `contains` or `affects` method to efficiently find
      * out if the event relates to a given resource. these methods ensure:
@@ -834,4 +898,4 @@ interface ICreateFileOptions {
     readonly overwrite?: boolean;
 }
 
-export { FileChangeType, FileChangesEvent, FileOperation, FileOperationEvent, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, type IBaseFileStat, type IBaseFileStatWithMetadata, type IBaseReadFileOptions, type ICreateFileOptions, type IFileAtomicDeleteOptions, type IFileAtomicOptions, type IFileAtomicReadOptions, type IFileAtomicWriteOptions, type IFileChange, type IFileContent, type IFileDeleteOptions, type IFileOpenForReadOptions, type IFileOpenForWriteOptions, type IFileOpenOptions, type IFileOperationEvent, type IFileOperationEventWithMetadata, type IFileOverwriteOptions, type IFileReadLimits, type IFileReadStreamOptions, IFileService, type IFileStat, type IFileStatResult, type IFileStatWithMetadata, type IFileStatWithPartialMetadata, type IFileStreamContent, type IFileSystemProvider, type IFileSystemProviderActivationEvent, type IFileSystemProviderCapabilitiesChangeEvent, type IFileSystemProviderError, type IFileSystemProviderRegistrationEvent, type IFileSystemProviderWithFileAtomicDeleteCapability, type IFileSystemProviderWithFileAtomicReadCapability, type IFileSystemProviderWithFileAtomicWriteCapability, type IFileSystemProviderWithFileReadStreamCapability, type IFileSystemProviderWithFileReadWriteCapability, type IFileSystemProviderWithOpenReadWriteCloseCapability, type IFileUnlockOptions, type IFileWriteOptions, type IReadFileOptions, type IReadFileStreamOptions, type IResolveFileOptions, type IResolveMetadataFileOptions, type IStat, type IWatchOptions, type IWriteFileOptions };
+export { FileChangeType, FileChangesEvent, FileOperation, FileOperationEvent, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, type IBaseFileStat, type IBaseFileStatWithMetadata, type IBaseReadFileOptions, type ICreateFileOptions, type IFileAtomicDeleteOptions, type IFileAtomicOptions, type IFileAtomicReadOptions, type IFileAtomicWriteOptions, type IFileChange, type IFileContent, type IFileDeleteOptions, type IFileOpenForReadOptions, type IFileOpenForWriteOptions, type IFileOpenOptions, type IFileOperationEvent, type IFileOperationEventWithMetadata, type IFileOverwriteOptions, type IFileReadLimits, type IFileReadStreamOptions, IFileService, type IFileStat, type IFileStatResult, type IFileStatWithMetadata, type IFileStatWithPartialMetadata, type IFileStreamContent, type IFileSystemProvider, type IFileSystemProviderActivationEvent, type IFileSystemProviderCapabilitiesChangeEvent, type IFileSystemProviderError, type IFileSystemProviderRegistrationEvent, type IFileSystemProviderWithFileAtomicDeleteCapability, type IFileSystemProviderWithFileAtomicReadCapability, type IFileSystemProviderWithFileAtomicWriteCapability, type IFileSystemProviderWithFileReadStreamCapability, type IFileSystemProviderWithFileReadWriteCapability, type IFileSystemProviderWithOpenReadWriteCloseCapability, type IFileSystemWatcher, type IFileUnlockOptions, type IFileWriteOptions, type IReadFileOptions, type IReadFileStreamOptions, type IResolveFileOptions, type IResolveMetadataFileOptions, type IStat, type IWatchOptions, type IWatchOptionsWithCorrelation, type IWatchOptionsWithoutCorrelation, type IWriteFileOptions };

package/vscode/src/vs/platform/files/common/watcher.js

@@ -0,0 +1,77 @@
+import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+class AbstractWatcherClient extends Disposable {
+    static { this.MAX_RESTARTS = 5; }
+    constructor(onFileChanges, onLogMessage, verboseLogging, options) {
+        super();
+        this.onFileChanges = onFileChanges;
+        this.onLogMessage = onLogMessage;
+        this.verboseLogging = verboseLogging;
+        this.options = options;
+        this.watcherDisposables = this._register(( new MutableDisposable()));
+        this.requests = undefined;
+        this.restartCounter = 0;
+    }
+    init() {
+        const disposables = ( new DisposableStore());
+        this.watcherDisposables.value = disposables;
+        this.watcher = this.createWatcher(disposables);
+        this.watcher.setVerboseLogging(this.verboseLogging);
+        disposables.add(this.watcher.onDidChangeFile(changes => this.onFileChanges(changes)));
+        disposables.add(this.watcher.onDidLogMessage(msg => this.onLogMessage(msg)));
+        disposables.add(this.watcher.onDidError(error => this.onError(error)));
+    }
+    onError(error) {
+        if (this.options.restartOnError) {
+            if (this.restartCounter < AbstractWatcherClient.MAX_RESTARTS && this.requests) {
+                this.error(`restarting watcher after error: ${error}`);
+                this.restart(this.requests);
+            }
+            else {
+                this.error(`gave up attempting to restart watcher after error: ${error}`);
+            }
+        }
+        else {
+            this.error(error);
+        }
+    }
+    restart(requests) {
+        this.restartCounter++;
+        this.init();
+        this.watch(requests);
+    }
+    async watch(requests) {
+        this.requests = requests;
+        await this.watcher?.watch(requests);
+    }
+    async setVerboseLogging(verboseLogging) {
+        this.verboseLogging = verboseLogging;
+        await this.watcher?.setVerboseLogging(verboseLogging);
+    }
+    error(message) {
+        this.onLogMessage({ type: 'error', message: `[File Watcher (${this.options.type})] ${message}` });
+    }
+    trace(message) {
+        this.onLogMessage({ type: 'trace', message: `[File Watcher (${this.options.type})] ${message}` });
+    }
+    dispose() {
+        this.watcher = undefined;
+        return super.dispose();
+    }
+}
+function reviveFileChanges(changes) {
+    return ( changes.map(change => ({
+        type: change.type,
+        resource: URI.revive(change.resource),
+        cId: change.cId
+    })));
+}
+function normalizeWatcherPattern(path, pattern) {
+    if (typeof pattern === 'string' && !pattern.startsWith(GLOBSTAR) && !isAbsolute(pattern)) {
+        return { base: path, pattern };
+    }
+    return pattern;
+}
+export { AbstractWatcherClient, normalizeWatcherPattern, reviveFileChanges };

package/vscode/src/vs/platform/keybinding/common/keybindingsRegistry.d.ts

@@ -1,5 +1,5 @@
 import { Keybinding } from '../../../base/common/keybindings.js';
-import { ICommandHandler, ICommandHandlerDescription } from '../../commands/common/commands.js';
+import { ICommandHandler, ICommandMetadata } from '../../commands/common/commands.js';
 import { ContextKeyExpression } from '../../contextkey/common/contextkey.js';
 import { IDisposable } from '../../../base/common/lifecycle.js';
 
@@ -46,7 +46,7 @@ interface IExtensionKeybindingRule {
 }
 interface ICommandAndKeybindingRule extends IKeybindingRule {
     handler: ICommandHandler;
-    description?: ICommandHandlerDescription | null;
+    metadata?: ICommandMetadata | null;
 }
 interface IKeybindingsRegistry {
     registerKeybindingRule(rule: IKeybindingRule): IDisposable;

package/vscode/src/vs/platform/layout/browser/layoutService.d.ts

@@ -1,6 +1,7 @@
 import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
 import { IDimension } from '../../../base/browser/dom.js';
 import { Event } from '../../../base/common/event.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
 
 interface ILayoutOffsetInfo {
     /**
@@ -17,37 +18,67 @@ declare const ILayoutService: ServiceIdentifier<ILayoutService>;
 interface ILayoutService {
     readonly _serviceBrand: undefined;
     /**
-     * The dimensions of the container.
+     * An event that is emitted when the main container is layed out.
      */
-    readonly dimension: IDimension;
+    readonly onDidLayoutMainContainer: Event<IDimension>;
     /**
-     * Does the application have a single container?
+     * An event that is emitted when any container is layed out.
      */
-    readonly hasContainer: boolean;
+    readonly onDidLayoutContainer: Event<{
+        readonly container: HTMLElement;
+        readonly dimension: IDimension;
+    }>;
     /**
-     * Container of the application.
-     *
-     * **NOTE**: In the standalone editor case, multiple editors can be created on a page.
-     * Therefore, in the standalone editor case, there are multiple containers, not just
-     * a single one. If you ship code that needs a "container" for the standalone editor,
-     * please use `ICodeEditorService` to get the current focused code editor and use its
-     * container if necessary. You can also instantiate `EditorScopedLayoutService`
-     * which implements `ILayoutService` but is not a part of the service collection because
-     * it is code editor instance specific.
-     *
+     * An event that is emitted when the active container is layed out.
      */
-    readonly container: HTMLElement;
+    readonly onDidLayoutActiveContainer: Event<IDimension>;
     /**
-     * An offset to use for positioning elements inside the container.
+     * An event that is emitted when a new container is added. This
+     * can happen in multi-window environments.
+     */
+    readonly onDidAddContainer: Event<{
+        readonly container: HTMLElement;
+        readonly disposables: DisposableStore;
+    }>;
+    /**
+     * An event that is emitted when the active container changes.
+     */
+    readonly onDidChangeActiveContainer: Event<void>;
+    /**
+     * The dimensions of the main container.
+     */
+    readonly mainContainerDimension: IDimension;
+    /**
+     * The dimensions of the active container.
+     */
+    readonly activeContainerDimension: IDimension;
+    /**
+     * Main container of the application.
      */
-    readonly offset: ILayoutOffsetInfo;
+    readonly mainContainer: HTMLElement;
     /**
-     * An event that is emitted when the container is layed out. The
-     * event carries the dimensions of the container as part of it.
+     * Active container of the application. When multiple windows are opened, will return
+     * the container of the active, focused window.
+     */
+    readonly activeContainer: HTMLElement;
+    /**
+     * All the containers of the application. There can be one container per window.
+     */
+    readonly containers: Iterable<HTMLElement>;
+    /**
+     * Get the container for the given window.
+     */
+    getContainer(window: Window): HTMLElement;
+    /**
+     * An offset to use for positioning elements inside the main container.
+     */
+    readonly mainContainerOffset: ILayoutOffsetInfo;
+    /**
+     * An offset to use for positioning elements inside the container.
      */
-    readonly onDidLayout: Event<IDimension>;
+    readonly activeContainerOffset: ILayoutOffsetInfo;
     /**
-     * Focus the primary component of the container.
+     * Focus the primary component of the active container.
      */
     focus(): void;
 }

package/vscode/src/vs/platform/request/browser/requestService.js

@@ -17,6 +17,9 @@ let RequestService = class RequestService extends AbstractRequestService {
     async resolveProxy(url) {
         return undefined;
     }
+    async loadCertificates() {
+        return [];
+    }
 };
 RequestService = ( __decorate([
     ( __param(0, IConfigurationService)),

package/vscode/src/vs/platform/request/common/requestIpc.js

@@ -0,0 +1,17 @@
+import { bufferToStream } from 'monaco-editor/esm/vs/base/common/buffer.js';
+class RequestChannelClient {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async request(options, token) {
+        const [res, buffer] = await this.channel.call('request', [options], token);
+        return { res, stream: bufferToStream(buffer) };
+    }
+    async resolveProxy(url) {
+        return this.channel.call('resolveProxy', [url]);
+    }
+    async loadCertificates() {
+        return this.channel.call('loadCertificates');
+    }
+}
+export { RequestChannelClient };

package/vscode/src/vs/platform/storage/common/storage.js

@@ -1,4 +1,4 @@
-import { RunOnceScheduler, runWhenIdle, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { RunOnceScheduler, runWhenGlobalIdle, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
 import { PauseableEmitter, Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
@@ -53,7 +53,7 @@ class AbstractStorageService extends Disposable {
         return Event.filter(this._onDidChangeValue.event, e => e.scope === scope && (key === undefined || e.key === key), disposable);
     }
     doFlushWhenIdle() {
-        this.runFlushWhenIdle.value = runWhenIdle(() => {
+        this.runFlushWhenIdle.value = runWhenGlobalIdle(() => {
             if (this.shouldFlushWhenIdle()) {
                 this.flush();
             }

package/vscode/src/vs/platform/telemetry/common/telemetry.d.ts

@@ -13,6 +13,7 @@ interface ITelemetryService {
     readonly telemetryLevel: TelemetryLevel;
     readonly sessionId: string;
     readonly machineId: string;
+    readonly sqmId: string;
     readonly firstSessionDate: string;
     readonly msftInternal?: boolean;
     /**

package/vscode/src/vs/platform/terminal/common/capabilities/bufferMarkCapability.js

@@ -0,0 +1,41 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class BufferMarkCapability extends Disposable {
+    constructor(_terminal) {
+        super();
+        this._terminal = _terminal;
+        this.type = 4 ;
+        this._idToMarkerMap = ( new Map());
+        this._anonymousMarkers = ( new Map());
+        this._onMarkAdded = this._register(( new Emitter()));
+        this.onMarkAdded = this._onMarkAdded.event;
+    }
+    *markers() {
+        for (const m of ( this._idToMarkerMap.values())) {
+            yield m;
+        }
+        for (const m of ( this._anonymousMarkers.values())) {
+            yield m;
+        }
+    }
+    addMark(properties) {
+        const marker = properties?.marker || this._terminal.registerMarker();
+        const id = properties?.id;
+        if (!marker) {
+            return;
+        }
+        if (id) {
+            this._idToMarkerMap.set(id, marker);
+            marker.onDispose(() => this._idToMarkerMap.delete(id));
+        }
+        else {
+            this._anonymousMarkers.set(marker.id, marker);
+            marker.onDispose(() => this._anonymousMarkers.delete(marker.id));
+        }
+        this._onMarkAdded.fire({ marker, id, hidden: properties?.hidden, hoverMessage: properties?.hoverMessage });
+    }
+    getMark(id) {
+        return this._idToMarkerMap.get(id);
+    }
+}
+export { BufferMarkCapability };

package/vscode/src/vs/platform/terminal/common/capabilities/capabilities.d.ts

@@ -1,6 +1,6 @@
 import { Event } from '../../../../base/common/event.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
-import { ICurrentPartialCommand } from './commandDetectionCapability.js';
+import { ICurrentPartialCommand } from './commandDetection/terminalCommand.js';
 import { ITerminalOutputMatcher, ITerminalOutputMatch } from '../terminal.js';
 
 interface IEvent<T, U = void> {
@@ -159,6 +159,7 @@ interface ICommandDetectionCapability {
      * case the terminal's initial cwd should be used.
      */
     getCwdForLine(line: number): string | undefined;
+    getCommandForLine(line: number): ITerminalCommand | ICurrentPartialCommand | undefined;
     handlePromptStart(options?: IHandleCommandOptions): void;
     handleContinuationStart(): void;
     handleContinuationEnd(): void;
@@ -167,7 +168,6 @@ interface ICommandDetectionCapability {
     handleCommandStart(options?: IHandleCommandOptions): void;
     handleCommandExecuted(options?: IHandleCommandOptions): void;
     handleCommandFinished(exitCode?: number, options?: IHandleCommandOptions): void;
-    invalidateCurrentCommand(request: ICommandInvalidationRequest): void;
     /**
      * Set the command line explicitly.
      * @param commandLine The command line being set.
@@ -213,20 +213,25 @@ interface IBaseTerminalCommand {
     exitCode: number | undefined;
     commandStartLineContent: string | undefined;
     markProperties: IMarkProperties | undefined;
+    executedX: number | undefined;
+    startX: number | undefined;
 }
 interface ITerminalCommand extends IBaseTerminalCommand {
-    marker?: IXtermMarker;
+    readonly promptStartMarker?: IMarker;
+    readonly marker?: IXtermMarker;
     endMarker?: IXtermMarker;
-    executedMarker?: IXtermMarker;
-    aliases?: string[][];
-    wasReplayed?: boolean;
+    readonly executedMarker?: IXtermMarker;
+    readonly aliases?: string[][];
+    readonly wasReplayed?: boolean;
     getOutput(): string | undefined;
     getOutputMatch(outputMatcher: ITerminalOutputMatcher): ITerminalOutputMatch | undefined;
     hasOutput(): boolean;
+    getPromptRowCount(): number;
+    getCommandRowCount(): number;
 }
 interface ISerializedTerminalCommand extends IBaseTerminalCommand {
     startLine: number | undefined;
-    startX: number | undefined;
+    promptStartLine: number | undefined;
     endLine: number | undefined;
     executedLine: number | undefined;
 }

package/vscode/src/vs/platform/terminal/common/capabilities/{commandDetectionCapability.d.ts → commandDetection/terminalCommand.d.ts}

@@ -1,7 +1,6 @@
-import { IMarker } from '../../../../../../../external/xterm-headless/typings/xterm-headless.js';
+import { IMarker } from '../capabilities.js';
 
 interface ICurrentPartialCommand {
-    previousCommandMarker?: IMarker;
     promptStartMarker?: IMarker;
     commandStartMarker?: IMarker;
     commandStartX?: number;
@@ -27,6 +26,8 @@ interface ICurrentPartialCommand {
      * event from firing.
      */
     isInvalid?: boolean;
+    getPromptRowCount(): number;
+    getCommandRowCount(): number;
 }
 
 export type { ICurrentPartialCommand };