@codingame/monaco-vscode-notebook-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,386 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Promises } from 'vscode/vscode/vs/base/common/async';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isEqual, toLocalResource, basename, dirname, joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { StoredFileWorkingCopyManager } from './storedFileWorkingCopyManager.js';
+import { UntitledFileWorkingCopy } from './untitledFileWorkingCopy.js';
+import { UntitledFileWorkingCopyManager } from './untitledFileWorkingCopyManager.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IDecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/common/decorations';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import { listErrorForeground } from 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { IFileDialogService, IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+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 };