@codingame/monaco-vscode-ac93482b-2178-52df-a200-ba0d1a4963fb-common 20.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@codingame/monaco-vscode-ac93482b-2178-52df-a200-ba0d1a4963fb-common",
+  "version": "20.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (chat, editor, explorer, interactive, notebook, output, search, view-common)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-615ce609-8555-545a-a549-47bd9f80e9f8-common": "20.0.0",
+    "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common": "20.0.0",
+    "@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common": "20.0.0",
+    "@codingame/monaco-vscode-api": "20.0.0",
+    "@codingame/monaco-vscode-bd0792ac-6043-5ec3-a41a-54ccb922a1f4-common": "20.0.0",
+    "@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common": "20.0.0",
+    "@codingame/monaco-vscode-dbfe5f85-b426-55ed-a79b-5f811b395762-common": "20.0.0",
+    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.0.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/workbench/browser/parts/editor/binaryEditor.d.ts

@@ -0,0 +1,23 @@
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+import { EditorPlaceholder, IEditorPlaceholderContents } from "@codingame/monaco-vscode-615ce609-8555-545a-a549-47bd9f80e9f8-common/vscode/vs/workbench/browser/parts/editor/editorPlaceholder";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+export interface IOpenCallbacks {
+    openInternal: (input: EditorInput, options: IEditorOptions | undefined) => Promise<void>;
+}
+export declare abstract class BaseBinaryResourceEditor extends EditorPlaceholder {
+    private readonly callbacks;
+    private readonly _onDidChangeMetadata;
+    readonly onDidChangeMetadata: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _onDidOpenInPlace;
+    readonly onDidOpenInPlace: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private metadata;
+    constructor(id: string, group: IEditorGroup, callbacks: IOpenCallbacks, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService);
+    getTitle(): string;
+    protected getContents(input: EditorInput, options: IEditorOptions): Promise<IEditorPlaceholderContents>;
+    private handleMetadataChanged;
+    getMetadata(): string | undefined;
+}

package/vscode/src/vs/workbench/browser/parts/editor/binaryEditor.js

@@ -0,0 +1,58 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { BinaryEditorModel } from '@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common/vscode/vs/workbench/common/editor/binaryEditorModel';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ByteSize } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { EditorPlaceholder } from '@codingame/monaco-vscode-615ce609-8555-545a-a549-47bd9f80e9f8-common/vscode/vs/workbench/browser/parts/editor/editorPlaceholder';
+
+let BaseBinaryResourceEditor = class BaseBinaryResourceEditor extends EditorPlaceholder {
+    constructor(id, group, callbacks, telemetryService, themeService, storageService) {
+        super(id, group, telemetryService, themeService, storageService);
+        this.callbacks = callbacks;
+        this._onDidChangeMetadata = this._register(( new Emitter()));
+        this.onDidChangeMetadata = this._onDidChangeMetadata.event;
+        this._onDidOpenInPlace = this._register(( new Emitter()));
+        this.onDidOpenInPlace = this._onDidOpenInPlace.event;
+    }
+    getTitle() {
+        return this.input ? this.input.getName() : ( localize(2963, "Binary Viewer"));
+    }
+    async getContents(input, options) {
+        const model = await input.resolve();
+        if (!(model instanceof BinaryEditorModel)) {
+            throw ( new Error('Unable to open file as binary'));
+        }
+        const size = model.getSize();
+        this.handleMetadataChanged(typeof size === 'number' ? ByteSize.formatSize(size) : '');
+        return {
+            icon: '$(warning)',
+            label: ( localize(
+                2964,
+                "The file is not displayed in the text editor because it is either binary or uses an unsupported text encoding."
+            )),
+            actions: [
+                {
+                    label: ( localize(2965, "Open Anyway")),
+                    run: async () => {
+                        await this.callbacks.openInternal(input, options);
+                        this._onDidOpenInPlace.fire();
+                    }
+                }
+            ]
+        };
+    }
+    handleMetadataChanged(meta) {
+        this.metadata = meta;
+        this._onDidChangeMetadata.fire();
+    }
+    getMetadata() {
+        return this.metadata;
+    }
+};
+BaseBinaryResourceEditor = ( __decorate([
+    ( __param(5, IStorageService))
+], BaseBinaryResourceEditor));
+
+export { BaseBinaryResourceEditor };

package/vscode/src/vs/workbench/browser/parts/editor/editor.contribution._autosave.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/browser/parts/editor/editor.contribution._autosave.js

@@ -0,0 +1,5 @@
+
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { EditorAutoSave } from './editorAutoSave.js';
+
+registerWorkbenchContribution2(EditorAutoSave.ID, EditorAutoSave, WorkbenchPhase.BlockRestore);

package/vscode/src/vs/workbench/browser/parts/editor/editorAutoSave.d.ts

@@ -0,0 +1,42 @@
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IWorkingCopyService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+export declare class EditorAutoSave extends Disposable implements IWorkbenchContribution {
+    private readonly filesConfigurationService;
+    private readonly hostService;
+    private readonly editorService;
+    private readonly editorGroupService;
+    private readonly workingCopyService;
+    private readonly logService;
+    private readonly markerService;
+    private readonly uriIdentityService;
+    static readonly ID = "workbench.contrib.editorAutoSave";
+    private readonly scheduledAutoSavesAfterDelay;
+    private lastActiveEditor;
+    private lastActiveGroupId;
+    private readonly lastActiveEditorControlDisposable;
+    private readonly waitingOnConditionAutoSaveWorkingCopies;
+    private readonly waitingOnConditionAutoSaveEditors;
+    constructor(filesConfigurationService: IFilesConfigurationService, hostService: IHostService, editorService: IEditorService, editorGroupService: IEditorGroupsService, workingCopyService: IWorkingCopyService, logService: ILogService, markerService: IMarkerService, uriIdentityService: IUriIdentityService);
+    private registerListeners;
+    private onConditionChanged;
+    private onWindowFocusChange;
+    private onActiveWindowChange;
+    private onDidActiveEditorChange;
+    private maybeTriggerAutoSave;
+    private onDidChangeAutoSaveConfiguration;
+    private saveAllDirtyAutoSaveables;
+    private onDidRegister;
+    private onDidUnregister;
+    private onDidChangeDirty;
+    private onDidChangeContent;
+    private scheduleAutoSave;
+    private discardAutoSave;
+}

package/vscode/src/vs/workbench/browser/parts/editor/editorAutoSave.js

@@ -0,0 +1,222 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableStore, toDisposable, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { AutoSaveDisabledReason, AutoSaveMode } from '@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { SaveReason, EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IWorkingCopyService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
+import { WorkingCopyCapabilities } from '@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+
+let EditorAutoSave = class EditorAutoSave extends Disposable {
+    static { this.ID = 'workbench.contrib.editorAutoSave'; }
+    constructor(filesConfigurationService, hostService, editorService, editorGroupService, workingCopyService, logService, markerService, uriIdentityService) {
+        super();
+        this.filesConfigurationService = filesConfigurationService;
+        this.hostService = hostService;
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.workingCopyService = workingCopyService;
+        this.logService = logService;
+        this.markerService = markerService;
+        this.uriIdentityService = uriIdentityService;
+        this.scheduledAutoSavesAfterDelay = ( new Map());
+        this.lastActiveEditor = undefined;
+        this.lastActiveGroupId = undefined;
+        this.lastActiveEditorControlDisposable = this._register(( new DisposableStore()));
+        this.waitingOnConditionAutoSaveWorkingCopies = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.waitingOnConditionAutoSaveEditors = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        for (const dirtyWorkingCopy of this.workingCopyService.dirtyWorkingCopies) {
+            this.onDidRegister(dirtyWorkingCopy);
+        }
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.hostService.onDidChangeFocus(focused => this.onWindowFocusChange(focused)));
+        this._register(this.hostService.onDidChangeActiveWindow(() => this.onActiveWindowChange()));
+        this._register(this.editorService.onDidActiveEditorChange(() => this.onDidActiveEditorChange()));
+        this._register(this.filesConfigurationService.onDidChangeAutoSaveConfiguration(() => this.onDidChangeAutoSaveConfiguration()));
+        this._register(this.workingCopyService.onDidRegister(workingCopy => this.onDidRegister(workingCopy)));
+        this._register(this.workingCopyService.onDidUnregister(workingCopy => this.onDidUnregister(workingCopy)));
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.onDidChangeDirty(workingCopy)));
+        this._register(this.workingCopyService.onDidChangeContent(workingCopy => this.onDidChangeContent(workingCopy)));
+        this._register(this.markerService.onMarkerChanged(e => this.onConditionChanged(e, AutoSaveDisabledReason.ERRORS)));
+        this._register(this.filesConfigurationService.onDidChangeAutoSaveDisabled(resource => this.onConditionChanged([resource], AutoSaveDisabledReason.DISABLED)));
+    }
+    onConditionChanged(resources, condition) {
+        for (const resource of resources) {
+            const workingCopyResult = this.waitingOnConditionAutoSaveWorkingCopies.get(resource);
+            if (workingCopyResult?.condition === condition) {
+                if (workingCopyResult.workingCopy.isDirty() &&
+                    this.filesConfigurationService.getAutoSaveMode(workingCopyResult.workingCopy.resource, workingCopyResult.reason).mode !== AutoSaveMode.OFF) {
+                    this.discardAutoSave(workingCopyResult.workingCopy);
+                    this.logService.trace(`[editor auto save] running auto save from condition change event`, ( workingCopyResult.workingCopy.resource.toString()), workingCopyResult.workingCopy.typeId);
+                    workingCopyResult.workingCopy.save({ reason: workingCopyResult.reason });
+                }
+            }
+            else {
+                const editorResult = this.waitingOnConditionAutoSaveEditors.get(resource);
+                if (editorResult?.condition === condition &&
+                    !editorResult.editor.editor.isDisposed() &&
+                    editorResult.editor.editor.isDirty() &&
+                    this.filesConfigurationService.getAutoSaveMode(editorResult.editor.editor, editorResult.reason).mode !== AutoSaveMode.OFF) {
+                    this.waitingOnConditionAutoSaveEditors.delete(resource);
+                    this.logService.trace(`[editor auto save] running auto save from condition change event with reason ${editorResult.reason}`);
+                    this.editorService.save(editorResult.editor, { reason: editorResult.reason });
+                }
+            }
+        }
+    }
+    onWindowFocusChange(focused) {
+        if (!focused) {
+            this.maybeTriggerAutoSave(SaveReason.WINDOW_CHANGE);
+        }
+    }
+    onActiveWindowChange() {
+        this.maybeTriggerAutoSave(SaveReason.WINDOW_CHANGE);
+    }
+    onDidActiveEditorChange() {
+        if (this.lastActiveEditor && typeof this.lastActiveGroupId === 'number') {
+            this.maybeTriggerAutoSave(SaveReason.FOCUS_CHANGE, { groupId: this.lastActiveGroupId, editor: this.lastActiveEditor });
+        }
+        const activeGroup = this.editorGroupService.activeGroup;
+        const activeEditor = this.lastActiveEditor = activeGroup.activeEditor ?? undefined;
+        this.lastActiveGroupId = activeGroup.id;
+        this.lastActiveEditorControlDisposable.clear();
+        const activeEditorPane = this.editorService.activeEditorPane;
+        if (activeEditor && activeEditorPane) {
+            this.lastActiveEditorControlDisposable.add(activeEditorPane.onDidBlur(() => {
+                this.maybeTriggerAutoSave(SaveReason.FOCUS_CHANGE, { groupId: activeGroup.id, editor: activeEditor });
+            }));
+        }
+    }
+    maybeTriggerAutoSave(reason, editorIdentifier) {
+        if (editorIdentifier) {
+            if (!editorIdentifier.editor.isDirty() ||
+                editorIdentifier.editor.isReadonly() ||
+                editorIdentifier.editor.hasCapability(EditorInputCapabilities.Untitled)) {
+                return;
+            }
+            const autoSaveMode = this.filesConfigurationService.getAutoSaveMode(editorIdentifier.editor, reason);
+            if (autoSaveMode.mode !== AutoSaveMode.OFF) {
+                if ((reason === SaveReason.WINDOW_CHANGE && (autoSaveMode.mode === AutoSaveMode.ON_FOCUS_CHANGE || autoSaveMode.mode === AutoSaveMode.ON_WINDOW_CHANGE)) ||
+                    (reason === SaveReason.FOCUS_CHANGE && autoSaveMode.mode === AutoSaveMode.ON_FOCUS_CHANGE)) {
+                    this.logService.trace(`[editor auto save] triggering auto save with reason ${reason}`);
+                    this.editorService.save(editorIdentifier, { reason });
+                }
+            }
+            else if (editorIdentifier.editor.resource && (autoSaveMode.reason === AutoSaveDisabledReason.ERRORS || autoSaveMode.reason === AutoSaveDisabledReason.DISABLED)) {
+                this.waitingOnConditionAutoSaveEditors.set(editorIdentifier.editor.resource, { editor: editorIdentifier, reason, condition: autoSaveMode.reason });
+            }
+        }
+        else {
+            this.saveAllDirtyAutoSaveables(reason);
+        }
+    }
+    onDidChangeAutoSaveConfiguration() {
+        let reason = undefined;
+        switch (this.filesConfigurationService.getAutoSaveMode(undefined).mode) {
+            case AutoSaveMode.ON_FOCUS_CHANGE:
+                reason = SaveReason.FOCUS_CHANGE;
+                break;
+            case AutoSaveMode.ON_WINDOW_CHANGE:
+                reason = SaveReason.WINDOW_CHANGE;
+                break;
+            case AutoSaveMode.AFTER_SHORT_DELAY:
+            case AutoSaveMode.AFTER_LONG_DELAY:
+                reason = SaveReason.AUTO;
+                break;
+        }
+        if (reason) {
+            this.saveAllDirtyAutoSaveables(reason);
+        }
+    }
+    saveAllDirtyAutoSaveables(reason) {
+        for (const workingCopy of this.workingCopyService.dirtyWorkingCopies) {
+            if (workingCopy.capabilities & WorkingCopyCapabilities.Untitled) {
+                continue;
+            }
+            const autoSaveMode = this.filesConfigurationService.getAutoSaveMode(workingCopy.resource, reason);
+            if (autoSaveMode.mode !== AutoSaveMode.OFF) {
+                workingCopy.save({ reason });
+            }
+            else if (autoSaveMode.reason === AutoSaveDisabledReason.ERRORS || autoSaveMode.reason === AutoSaveDisabledReason.DISABLED) {
+                this.waitingOnConditionAutoSaveWorkingCopies.set(workingCopy.resource, { workingCopy, reason, condition: autoSaveMode.reason });
+            }
+        }
+    }
+    onDidRegister(workingCopy) {
+        if (workingCopy.isDirty()) {
+            this.scheduleAutoSave(workingCopy);
+        }
+    }
+    onDidUnregister(workingCopy) {
+        this.discardAutoSave(workingCopy);
+    }
+    onDidChangeDirty(workingCopy) {
+        if (workingCopy.isDirty()) {
+            this.scheduleAutoSave(workingCopy);
+        }
+        else {
+            this.discardAutoSave(workingCopy);
+        }
+    }
+    onDidChangeContent(workingCopy) {
+        if (workingCopy.isDirty()) {
+            this.scheduleAutoSave(workingCopy);
+        }
+    }
+    scheduleAutoSave(workingCopy) {
+        if (workingCopy.capabilities & WorkingCopyCapabilities.Untitled) {
+            return;
+        }
+        const autoSaveAfterDelay = this.filesConfigurationService.getAutoSaveConfiguration(workingCopy.resource).autoSaveDelay;
+        if (typeof autoSaveAfterDelay !== 'number') {
+            return;
+        }
+        this.discardAutoSave(workingCopy);
+        this.logService.trace(`[editor auto save] scheduling auto save after ${autoSaveAfterDelay}ms`, ( workingCopy.resource.toString()), workingCopy.typeId);
+        const handle = setTimeout(() => {
+            this.discardAutoSave(workingCopy);
+            if (workingCopy.isDirty()) {
+                const reason = SaveReason.AUTO;
+                const autoSaveMode = this.filesConfigurationService.getAutoSaveMode(workingCopy.resource, reason);
+                if (autoSaveMode.mode !== AutoSaveMode.OFF) {
+                    this.logService.trace(`[editor auto save] running auto save`, ( workingCopy.resource.toString()), workingCopy.typeId);
+                    workingCopy.save({ reason });
+                }
+                else if (autoSaveMode.reason === AutoSaveDisabledReason.ERRORS || autoSaveMode.reason === AutoSaveDisabledReason.DISABLED) {
+                    this.waitingOnConditionAutoSaveWorkingCopies.set(workingCopy.resource, { workingCopy, reason, condition: autoSaveMode.reason });
+                }
+            }
+        }, autoSaveAfterDelay);
+        this.scheduledAutoSavesAfterDelay.set(workingCopy, toDisposable(() => {
+            this.logService.trace(`[editor auto save] clearing pending auto save`, ( workingCopy.resource.toString()), workingCopy.typeId);
+            clearTimeout(handle);
+        }));
+    }
+    discardAutoSave(workingCopy) {
+        dispose(this.scheduledAutoSavesAfterDelay.get(workingCopy));
+        this.scheduledAutoSavesAfterDelay.delete(workingCopy);
+        this.waitingOnConditionAutoSaveWorkingCopies.delete(workingCopy.resource);
+        this.waitingOnConditionAutoSaveEditors.delete(workingCopy.resource);
+    }
+};
+EditorAutoSave = ( __decorate([
+    ( __param(0, IFilesConfigurationService)),
+    ( __param(1, IHostService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IEditorGroupsService)),
+    ( __param(4, IWorkingCopyService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IMarkerService)),
+    ( __param(7, IUriIdentityService))
+], EditorAutoSave));
+
+export { EditorAutoSave };

package/vscode/src/vs/workbench/contrib/files/browser/editors/textFileSaveErrorHandler.d.ts

@@ -0,0 +1,32 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ISaveErrorHandler, ITextFileEditorModel, ITextFileSaveOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { ServicesAccessor, IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+export declare const CONFLICT_RESOLUTION_CONTEXT = "saveConflictResolutionContext";
+export declare const CONFLICT_RESOLUTION_SCHEME = "conflictResolution";
+export declare class TextFileSaveErrorHandler extends Disposable implements ISaveErrorHandler, IWorkbenchContribution {
+    private readonly notificationService;
+    private readonly textFileService;
+    private readonly editorService;
+    private readonly instantiationService;
+    private readonly storageService;
+    static readonly ID = "workbench.contrib.textFileSaveErrorHandler";
+    private readonly messages;
+    private readonly conflictResolutionContext;
+    private activeConflictResolutionResource;
+    constructor(notificationService: INotificationService, textFileService: ITextFileService, contextKeyService: IContextKeyService, editorService: IEditorService, textModelService: ITextModelService, instantiationService: IInstantiationService, storageService: IStorageService);
+    private registerListeners;
+    private onActiveEditorChanged;
+    private onFileSavedOrReverted;
+    onSaveError(error: unknown, model: ITextFileEditorModel, options: ITextFileSaveOptions): void;
+    dispose(): void;
+}
+export declare const acceptLocalChangesCommand: (accessor: ServicesAccessor, resource: URI) => Promise<boolean | undefined>;
+export declare const revertLocalChangesCommand: (accessor: ServicesAccessor, resource: URI) => Promise<boolean | undefined>;