@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSyncUtil.js

@@ -0,0 +1,46 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { getDefaultIgnoredSettings } from '../../../../platform/userDataSync/common/userDataSync.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { ITextResourcePropertiesService, ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+let UserDataSyncUtilService = class UserDataSyncUtilService {
+    constructor(keybindingsService, textModelService, textResourcePropertiesService, textResourceConfigurationService) {
+        this.keybindingsService = keybindingsService;
+        this.textModelService = textModelService;
+        this.textResourcePropertiesService = textResourcePropertiesService;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+    }
+    async resolveDefaultIgnoredSettings() {
+        return getDefaultIgnoredSettings();
+    }
+    async resolveUserBindings(userBindings) {
+        const keys = {};
+        for (const userbinding of userBindings) {
+            keys[userbinding] = ( this.keybindingsService.resolveUserBinding(userbinding).map(part => part.getUserSettingsLabel())).join(' ');
+        }
+        return keys;
+    }
+    async resolveFormattingOptions(resource) {
+        try {
+            const modelReference = await this.textModelService.createModelReference(resource);
+            const { insertSpaces, tabSize } = modelReference.object.textEditorModel.getOptions();
+            const eol = modelReference.object.textEditorModel.getEOL();
+            modelReference.dispose();
+            return { eol, insertSpaces, tabSize };
+        }
+        catch (e) {
+        }
+        return {
+            eol: this.textResourcePropertiesService.getEOL(resource),
+            insertSpaces: !!this.textResourceConfigurationService.getValue(resource, 'editor.insertSpaces'),
+            tabSize: this.textResourceConfigurationService.getValue(resource, 'editor.tabSize')
+        };
+    }
+};
+UserDataSyncUtilService = ( __decorate([
+    ( __param(0, IKeybindingService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, ITextResourcePropertiesService)),
+    ( __param(3, ITextResourceConfigurationService))
+], UserDataSyncUtilService));
+export { UserDataSyncUtilService };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js

@@ -0,0 +1,23 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { WorkingCopyBackupService } from '../common/workingCopyBackupService.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import { joinPath } from '../../../../base/common/resources.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
+import { BrowserWorkingCopyBackupTracker } from './workingCopyBackupTracker.js';
+let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
+    constructor(contextService, environmentService, fileService, logService) {
+        super(joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
+    }
+};
+BrowserWorkingCopyBackupService = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IFileService)),
+    ( __param(3, ILogService))
+], BrowserWorkingCopyBackupService));
+registerWorkbenchContribution2(BrowserWorkingCopyBackupTracker.ID, BrowserWorkingCopyBackupTracker, 1 );
+export { BrowserWorkingCopyBackupService };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupTracker.js

@@ -0,0 +1,43 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IWorkingCopyBackupService } from '../common/workingCopyBackup.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
+import { IWorkingCopyService } from '../common/workingCopyService.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { WorkingCopyBackupTracker } from '../common/workingCopyBackupTracker.js';
+import { IWorkingCopyEditorService } from '../common/workingCopyEditorService.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IEditorGroupsService } from '../../editor/common/editorGroupsService.js';
+let BrowserWorkingCopyBackupTracker = class BrowserWorkingCopyBackupTracker extends WorkingCopyBackupTracker {
+    static { this.ID = 'workbench.contrib.browserWorkingCopyBackupTracker'; }
+    constructor(workingCopyBackupService, filesConfigurationService, workingCopyService, lifecycleService, logService, workingCopyEditorService, editorService, editorGroupService) {
+        super(workingCopyBackupService, workingCopyService, logService, lifecycleService, filesConfigurationService, workingCopyEditorService, editorService, editorGroupService);
+    }
+    onFinalBeforeShutdown(reason) {
+        const modifiedWorkingCopies = this.workingCopyService.modifiedWorkingCopies;
+        if (!modifiedWorkingCopies.length) {
+            return false;
+        }
+        if (!this.filesConfigurationService.isHotExitEnabled) {
+            return true;
+        }
+        for (const modifiedWorkingCopy of modifiedWorkingCopies) {
+            if (!this.workingCopyBackupService.hasBackupSync(modifiedWorkingCopy, this.getContentVersion(modifiedWorkingCopy))) {
+                this.logService.warn('Unload veto: pending backups');
+                return true;
+            }
+        }
+        return false;
+    }
+};
+BrowserWorkingCopyBackupTracker = ( __decorate([
+    ( __param(0, IWorkingCopyBackupService)),
+    ( __param(1, IFilesConfigurationService)),
+    ( __param(2, IWorkingCopyService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IWorkingCopyEditorService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IEditorGroupsService))
+], BrowserWorkingCopyBackupTracker));
+export { BrowserWorkingCopyBackupTracker };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js

@@ -0,0 +1,28 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { WorkingCopyHistoryService } from '../common/workingCopyHistoryService.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+let BrowserWorkingCopyHistoryService = class BrowserWorkingCopyHistoryService extends WorkingCopyHistoryService {
+    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
+        super(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService);
+    }
+    getModelOptions() {
+        return { flushOnChange: true  };
+    }
+};
+BrowserWorkingCopyHistoryService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IUriIdentityService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IConfigurationService))
+], BrowserWorkingCopyHistoryService));
+export { BrowserWorkingCopyHistoryService };

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.js

@@ -0,0 +1,87 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, dispose } from '../../../../base/common/lifecycle.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { Promises } from '../../../../base/common/async.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IWorkingCopyBackupService } from './workingCopyBackup.js';
+let BaseFileWorkingCopyManager = class BaseFileWorkingCopyManager extends Disposable {
+    constructor(fileService, logService, workingCopyBackupService) {
+        super();
+        this.fileService = fileService;
+        this.logService = logService;
+        this.workingCopyBackupService = workingCopyBackupService;
+        this._onDidCreate = this._register(( new Emitter()));
+        this.onDidCreate = this._onDidCreate.event;
+        this.mapResourceToWorkingCopy = ( new ResourceMap());
+        this.mapResourceToDisposeListener = ( new ResourceMap());
+    }
+    has(resource) {
+        return ( this.mapResourceToWorkingCopy.has(resource));
+    }
+    add(resource, workingCopy) {
+        const knownWorkingCopy = this.get(resource);
+        if (knownWorkingCopy === workingCopy) {
+            return;
+        }
+        this.mapResourceToWorkingCopy.set(resource, workingCopy);
+        this.mapResourceToDisposeListener.get(resource)?.dispose();
+        this.mapResourceToDisposeListener.set(resource, workingCopy.onWillDispose(() => this.remove(resource)));
+        this._onDidCreate.fire(workingCopy);
+    }
+    remove(resource) {
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        if (disposeListener) {
+            dispose(disposeListener);
+            this.mapResourceToDisposeListener.delete(resource);
+        }
+        return this.mapResourceToWorkingCopy.delete(resource);
+    }
+    get workingCopies() {
+        return [...( this.mapResourceToWorkingCopy.values())];
+    }
+    get(resource) {
+        return this.mapResourceToWorkingCopy.get(resource);
+    }
+    dispose() {
+        super.dispose();
+        this.mapResourceToWorkingCopy.clear();
+        dispose(( this.mapResourceToDisposeListener.values()));
+        this.mapResourceToDisposeListener.clear();
+    }
+    async destroy() {
+        try {
+            await Promises.settled(( this.workingCopies.map(async (workingCopy) => {
+                if (workingCopy.isDirty()) {
+                    await this.saveWithFallback(workingCopy);
+                }
+            })));
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        dispose(( this.mapResourceToWorkingCopy.values()));
+        this.dispose();
+    }
+    async saveWithFallback(workingCopy) {
+        let saveSuccess = false;
+        try {
+            saveSuccess = await workingCopy.save();
+        }
+        catch (error) {
+        }
+        if (!saveSuccess || workingCopy.isDirty()) {
+            const backup = await this.workingCopyBackupService.resolve(workingCopy);
+            if (backup) {
+                await this.fileService.writeFile(workingCopy.resource, backup.value, { unlock: true });
+            }
+        }
+    }
+};
+BaseFileWorkingCopyManager = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IWorkingCopyBackupService))
+], BaseFileWorkingCopyManager));
+export { BaseFileWorkingCopyManager };

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.js

@@ -0,0 +1,384 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { Promises } from '../../../../base/common/async.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isEqual, toLocalResource, basename, dirname, joinPath } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { SaveSourceRegistry } from '../../../common/editor.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IPathService } from '../../path/common/pathService.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { StoredFileWorkingCopyManager } from './storedFileWorkingCopyManager.js';
+import { UntitledFileWorkingCopy } from './untitledFileWorkingCopy.js';
+import { UntitledFileWorkingCopyManager } from './untitledFileWorkingCopyManager.js';
+import { IWorkingCopyFileService } from './workingCopyFileService.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IElevatedFileService } from '../../files/common/elevatedFileService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { IWorkingCopyBackupService } from './workingCopyBackup.js';
+import { IWorkingCopyEditorService } from './workingCopyEditorService.js';
+import { IWorkingCopyService } from './workingCopyService.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IDecorationsService } from '../../decorations/common/decorations.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listErrorForeground } from '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IFileDialogService, IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var FileWorkingCopyManager_1;
+let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
+    static { FileWorkingCopyManager_1 = this; }
+    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+        'fileWorkingCopyCreate.source',
+        "File Created"
+    ))); }
+    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+        'fileWorkingCopyReplace.source',
+        "File Replaced"
+    ))); }
+    constructor(workingCopyTypeId, storedWorkingCopyModelFactory, untitledWorkingCopyModelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, fileDialogService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, pathService, environmentService, dialogService, decorationsService) {
+        super();
+        this.workingCopyTypeId = workingCopyTypeId;
+        this.storedWorkingCopyModelFactory = storedWorkingCopyModelFactory;
+        this.untitledWorkingCopyModelFactory = untitledWorkingCopyModelFactory;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileDialogService = fileDialogService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.pathService = pathService;
+        this.environmentService = environmentService;
+        this.dialogService = dialogService;
+        this.decorationsService = decorationsService;
+        this.stored = this._register(( new StoredFileWorkingCopyManager(
+            this.workingCopyTypeId,
+            this.storedWorkingCopyModelFactory,
+            fileService,
+            lifecycleService,
+            labelService,
+            logService,
+            workingCopyFileService,
+            workingCopyBackupService,
+            uriIdentityService,
+            filesConfigurationService,
+            workingCopyService,
+            notificationService,
+            workingCopyEditorService,
+            editorService,
+            elevatedFileService
+        )));
+        this.untitled = this._register(( new UntitledFileWorkingCopyManager(
+            this.workingCopyTypeId,
+            this.untitledWorkingCopyModelFactory,
+            async (workingCopy, options) => {
+                const result = await this.saveAs(workingCopy.resource, undefined, options);
+                return result ? true : false;
+            },
+            fileService,
+            labelService,
+            logService,
+            workingCopyBackupService,
+            workingCopyService
+        )));
+        this.onDidCreate = Event.any(this.stored.onDidCreate, this.untitled.onDidCreate);
+        this.provideDecorations();
+    }
+    provideDecorations() {
+        const provider = this._register(new (class extends Disposable {
+            constructor(stored) {
+                super();
+                this.stored = stored;
+                this.label = ( localizeWithPath(
+                    'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                    'fileWorkingCopyDecorations',
+                    "File Working Copy Decorations"
+                ));
+                this._onDidChange = this._register(( new Emitter()));
+                this.onDidChange = this._onDidChange.event;
+                this.registerListeners();
+            }
+            registerListeners() {
+                this._register(this.stored.onDidResolve(workingCopy => {
+                    if (workingCopy.isReadonly() || workingCopy.hasState(4 )) {
+                        this._onDidChange.fire([workingCopy.resource]);
+                    }
+                }));
+                this._register(this.stored.onDidRemove(workingCopyUri => this._onDidChange.fire([workingCopyUri])));
+                this._register(this.stored.onDidChangeReadonly(workingCopy => this._onDidChange.fire([workingCopy.resource])));
+                this._register(this.stored.onDidChangeOrphaned(workingCopy => this._onDidChange.fire([workingCopy.resource])));
+            }
+            provideDecorations(uri) {
+                const workingCopy = this.stored.get(uri);
+                if (!workingCopy || workingCopy.isDisposed()) {
+                    return undefined;
+                }
+                const isReadonly = workingCopy.isReadonly();
+                const isOrphaned = workingCopy.hasState(4 );
+                if (isReadonly && isOrphaned) {
+                    return {
+                        color: listErrorForeground,
+                        letter: Codicon.lockSmall,
+                        strikethrough: true,
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                            'readonlyAndDeleted',
+                            "Deleted, Read-only"
+                        )),
+                    };
+                }
+                else if (isReadonly) {
+                    return {
+                        letter: Codicon.lockSmall,
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                            'readonly',
+                            "Read-only"
+                        )),
+                    };
+                }
+                else if (isOrphaned) {
+                    return {
+                        color: listErrorForeground,
+                        strikethrough: true,
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                            'deleted',
+                            "Deleted"
+                        )),
+                    };
+                }
+                return undefined;
+            }
+        })(this.stored));
+        this._register(this.decorationsService.registerDecorationsProvider(provider));
+    }
+    get workingCopies() {
+        return [...this.stored.workingCopies, ...this.untitled.workingCopies];
+    }
+    get(resource) {
+        return this.stored.get(resource) ?? this.untitled.get(resource);
+    }
+    resolve(arg1, arg2) {
+        if (URI.isUri(arg1)) {
+            if (arg1.scheme === Schemas.untitled) {
+                return this.untitled.resolve({ untitledResource: arg1 });
+            }
+            else {
+                return this.stored.resolve(arg1, arg2);
+            }
+        }
+        return this.untitled.resolve(arg1);
+    }
+    async saveAs(source, target, options) {
+        if (!target) {
+            const workingCopy = this.get(source);
+            if (workingCopy instanceof UntitledFileWorkingCopy && workingCopy.hasAssociatedFilePath) {
+                target = await this.suggestSavePath(source);
+            }
+            else {
+                target = await this.fileDialogService.pickFileToSave(await this.suggestSavePath(options?.suggestedTarget ?? source), options?.availableFileSystems);
+            }
+        }
+        if (!target) {
+            return;
+        }
+        if (this.filesConfigurationService.isReadonly(target)) {
+            const confirmed = await this.confirmMakeWriteable(target);
+            if (!confirmed) {
+                return;
+            }
+            else {
+                this.filesConfigurationService.updateReadonly(target, false);
+            }
+        }
+        if (this.fileService.hasProvider(source) && isEqual(source, target)) {
+            return this.doSave(source, { ...options, force: true  });
+        }
+        if (this.fileService.hasProvider(source) && this.uriIdentityService.extUri.isEqual(source, target) && (await this.fileService.exists(source))) {
+            await this.workingCopyFileService.move([{ file: { source, target } }], CancellationToken.None);
+            return (await this.doSave(source, options)) ?? (await this.doSave(target, options));
+        }
+        return this.doSaveAs(source, target, options);
+    }
+    async doSave(resource, options) {
+        const storedFileWorkingCopy = this.stored.get(resource);
+        if (storedFileWorkingCopy) {
+            const success = await storedFileWorkingCopy.save(options);
+            if (success) {
+                return storedFileWorkingCopy;
+            }
+        }
+        return undefined;
+    }
+    async doSaveAs(source, target, options) {
+        let sourceContents;
+        const sourceWorkingCopy = this.get(source);
+        if (sourceWorkingCopy?.isResolved()) {
+            sourceContents = await sourceWorkingCopy.model.snapshot(CancellationToken.None);
+        }
+        else {
+            sourceContents = (await this.fileService.readFileStream(source)).value;
+        }
+        const { targetFileExists, targetStoredFileWorkingCopy } = await this.doResolveSaveTarget(source, target);
+        if (sourceWorkingCopy instanceof UntitledFileWorkingCopy &&
+            sourceWorkingCopy.hasAssociatedFilePath &&
+            targetFileExists &&
+            this.uriIdentityService.extUri.isEqual(target, toLocalResource(sourceWorkingCopy.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme))) {
+            const overwrite = await this.confirmOverwrite(target);
+            if (!overwrite) {
+                return undefined;
+            }
+        }
+        await targetStoredFileWorkingCopy.model?.update(sourceContents, CancellationToken.None);
+        if (!options?.source) {
+            options = {
+                ...options,
+                source: targetFileExists ? FileWorkingCopyManager_1.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE : FileWorkingCopyManager_1.FILE_WORKING_COPY_SAVE_CREATE_SOURCE
+            };
+        }
+        const success = await targetStoredFileWorkingCopy.save({
+            ...options,
+            from: source,
+            force: true
+        });
+        if (!success) {
+            return undefined;
+        }
+        try {
+            await sourceWorkingCopy?.revert();
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return targetStoredFileWorkingCopy;
+    }
+    async doResolveSaveTarget(source, target) {
+        let targetFileExists = false;
+        let targetStoredFileWorkingCopy = this.stored.get(target);
+        if (targetStoredFileWorkingCopy?.isResolved()) {
+            targetFileExists = true;
+        }
+        else {
+            targetFileExists = await this.fileService.exists(target);
+            if (!targetFileExists) {
+                await this.workingCopyFileService.create([{ resource: target }], CancellationToken.None);
+            }
+            if (this.uriIdentityService.extUri.isEqual(source, target) && this.get(source)) {
+                targetStoredFileWorkingCopy = await this.stored.resolve(source);
+            }
+            else {
+                targetStoredFileWorkingCopy = await this.stored.resolve(target);
+            }
+        }
+        return { targetFileExists, targetStoredFileWorkingCopy };
+    }
+    async confirmOverwrite(resource) {
+        const { confirmed } = await this.dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'confirmOverwrite',
+                "'{0}' already exists. Do you want to replace it?",
+                basename(resource)
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'overwriteIrreversible',
+                "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
+                basename(resource),
+                basename(dirname(resource))
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                { key: 'replaceButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Replace"
+            ))
+        });
+        return confirmed;
+    }
+    async confirmMakeWriteable(resource) {
+        const { confirmed } = await this.dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'confirmMakeWriteable',
+                "'{0}' is marked as read-only. Do you want to save anyway?",
+                basename(resource)
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'confirmMakeWriteableDetail',
+                "Paths can be configured as read-only via settings."
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                { key: 'makeWriteableButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Save Anyway"
+            ))
+        });
+        return confirmed;
+    }
+    async suggestSavePath(resource) {
+        if (this.fileService.hasProvider(resource)) {
+            return resource;
+        }
+        const workingCopy = this.get(resource);
+        if (workingCopy instanceof UntitledFileWorkingCopy && workingCopy.hasAssociatedFilePath) {
+            return toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+        }
+        const defaultFilePath = await this.fileDialogService.defaultFilePath();
+        if (workingCopy) {
+            const candidatePath = joinPath(defaultFilePath, workingCopy.name);
+            if (await this.pathService.hasValidBasename(candidatePath, workingCopy.name)) {
+                return candidatePath;
+            }
+        }
+        return joinPath(defaultFilePath, basename(resource));
+    }
+    async destroy() {
+        await Promises.settled([
+            this.stored.destroy(),
+            this.untitled.destroy()
+        ]);
+    }
+};
+FileWorkingCopyManager = FileWorkingCopyManager_1 = ( __decorate([
+    ( __param(3, IFileService)),
+    ( __param(4, ILifecycleService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IWorkingCopyFileService)),
+    ( __param(8, IWorkingCopyBackupService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, IFileDialogService)),
+    ( __param(11, IFilesConfigurationService)),
+    ( __param(12, IWorkingCopyService)),
+    ( __param(13, INotificationService)),
+    ( __param(14, IWorkingCopyEditorService)),
+    ( __param(15, IEditorService)),
+    ( __param(16, IElevatedFileService)),
+    ( __param(17, IPathService)),
+    ( __param(18, IWorkbenchEnvironmentService)),
+    ( __param(19, IDialogService)),
+    ( __param(20, IDecorationsService))
+], FileWorkingCopyManager));
+export { FileWorkingCopyManager };