@codingame/monaco-vscode-notebook-service-override 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModel.js

@@ -0,0 +1,352 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { streamToBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { hasKey, assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { FileOperationError, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { EditorModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorModel';
+import { NotebookCellsChangeType, NotebookSetting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
+import { SimpleNotebookProviderInfo } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { StoredFileWorkingCopyState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
+import { WorkingCopyCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+
+var SimpleNotebookEditorModel_1;
+let SimpleNotebookEditorModel = SimpleNotebookEditorModel_1 = class SimpleNotebookEditorModel extends EditorModel {
+    constructor(
+        resource,
+        _hasAssociatedFilePath,
+        viewType,
+        _workingCopyManager,
+        scratchpad,
+        _filesConfigurationService
+    ) {
+        super();
+        this.resource = resource;
+        this._hasAssociatedFilePath = _hasAssociatedFilePath;
+        this.viewType = viewType;
+        this._workingCopyManager = _workingCopyManager;
+        this._filesConfigurationService = _filesConfigurationService;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this._onDidSave = this._register(( new Emitter()));
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this._onDidRevertUntitled = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this.onDidSave = this._onDidSave.event;
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this.onDidRevertUntitled = this._onDidRevertUntitled.event;
+        this._workingCopyListeners = this._register(( new DisposableStore()));
+        this.scratchPad = scratchpad;
+    }
+    dispose() {
+        this._workingCopy?.dispose();
+        super.dispose();
+    }
+    get notebook() {
+        return this._workingCopy?.model?.notebookModel;
+    }
+    isResolved() {
+        return Boolean(this._workingCopy?.model?.notebookModel);
+    }
+    async canDispose() {
+        if (!this._workingCopy) {
+            return true;
+        }
+        if (SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy)) {
+            return this._workingCopyManager.stored.canDispose(this._workingCopy);
+        } else {
+            return true;
+        }
+    }
+    isDirty() {
+        return this._workingCopy?.isDirty() ?? false;
+    }
+    isModified() {
+        return this._workingCopy?.isModified() ?? false;
+    }
+    isOrphaned() {
+        return SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy) && this._workingCopy.hasState(StoredFileWorkingCopyState.ORPHAN);
+    }
+    hasAssociatedFilePath() {
+        return !SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy) && !!this._workingCopy?.hasAssociatedFilePath;
+    }
+    isReadonly() {
+        if (SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy)) {
+            return this._workingCopy?.isReadonly();
+        } else {
+            return this._filesConfigurationService.isReadonly(this.resource);
+        }
+    }
+    get hasErrorState() {
+        if (this._workingCopy && hasKey(this._workingCopy, {
+            hasState: true
+        })) {
+            return this._workingCopy.hasState(StoredFileWorkingCopyState.ERROR);
+        }
+        return false;
+    }
+    async revert(options) {
+        assertType(this.isResolved());
+        return this._workingCopy.revert(options);
+    }
+    async save(options) {
+        assertType(this.isResolved());
+        return this._workingCopy.save(options);
+    }
+    async load(options) {
+        if (!this._workingCopy || !this._workingCopy.model) {
+            if (this.resource.scheme === Schemas.untitled) {
+                if (this._hasAssociatedFilePath) {
+                    this._workingCopy = await this._workingCopyManager.resolve({
+                        associatedResource: this.resource
+                    });
+                } else {
+                    this._workingCopy = await this._workingCopyManager.resolve({
+                        untitledResource: this.resource,
+                        isScratchpad: this.scratchPad
+                    });
+                }
+                this._register(this._workingCopy.onDidRevert(() => this._onDidRevertUntitled.fire()));
+            } else {
+                this._workingCopy = await this._workingCopyManager.resolve(this.resource, {
+                    limits: options?.limits,
+                    reload: options?.forceReadFromFile ? {
+                        async: false,
+                        force: true
+                    } : undefined
+                });
+                this._workingCopyListeners.add(this._workingCopy.onDidSave(e => this._onDidSave.fire(e)));
+                this._workingCopyListeners.add(
+                    this._workingCopy.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire())
+                );
+                this._workingCopyListeners.add(
+                    this._workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire())
+                );
+            }
+            this._workingCopyListeners.add(
+                this._workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(), undefined)
+            );
+            this._workingCopyListeners.add(this._workingCopy.onWillDispose(() => {
+                this._workingCopyListeners.clear();
+                this._workingCopy?.model?.dispose();
+            }));
+        } else {
+            await this._workingCopyManager.resolve(this.resource, {
+                reload: {
+                    async: !options?.forceReadFromFile,
+                    force: options?.forceReadFromFile
+                },
+                limits: options?.limits
+            });
+        }
+        assertType(this.isResolved());
+        return this;
+    }
+    async saveAs(target) {
+        const newWorkingCopy = await this._workingCopyManager.saveAs(this.resource, target);
+        if (!newWorkingCopy) {
+            return undefined;
+        }
+        return {
+            resource: newWorkingCopy.resource
+        };
+    }
+    static _isStoredFileWorkingCopy(candidate) {
+        const isUntitled = candidate && candidate.capabilities & WorkingCopyCapabilities.Untitled;
+        return !isUntitled;
+    }
+};
+SimpleNotebookEditorModel = SimpleNotebookEditorModel_1 = ( __decorate([( __param(5, IFilesConfigurationService))], SimpleNotebookEditorModel));
+class NotebookFileWorkingCopyModel extends Disposable {
+    constructor(
+        _notebookModel,
+        _notebookService,
+        _configurationService,
+        _telemetryService,
+        _notebookLogService
+    ) {
+        super();
+        this._notebookModel = _notebookModel;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+        this._telemetryService = _telemetryService;
+        this._notebookLogService = _notebookLogService;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this.configuration = undefined;
+        this.onWillDispose = _notebookModel.onWillDispose.bind(_notebookModel);
+        this._register(_notebookModel.onDidChangeContent(e => {
+            for (const rawEvent of e.rawEvents) {
+                if (rawEvent.kind === NotebookCellsChangeType.Initialize) {
+                    continue;
+                }
+                if (rawEvent.transient) {
+                    continue;
+                }
+                this._onDidChangeContent.fire({
+                    isRedoing: false,
+                    isUndoing: false,
+                    isInitial: false
+                });
+                break;
+            }
+        }));
+        const saveWithReducedCommunication = this._configurationService.getValue(NotebookSetting.remoteSaving);
+        if (saveWithReducedCommunication || _notebookModel.uri.scheme === Schemas.vscodeRemote) {
+            this.configuration = {
+                backupDelay: 10000
+            };
+        }
+        if (saveWithReducedCommunication) {
+            this.setSaveDelegate().catch(
+                error => this._notebookLogService.error("WorkingCopyModel", `Failed to set save delegate: ${error}`)
+            );
+        }
+    }
+    async setSaveDelegate() {
+        await this.getNotebookSerializer();
+        this.save = async (options, token) => {
+            try {
+                let serializer = this._notebookService.tryGetDataProviderSync(this.notebookModel.viewType)?.serializer;
+                if (!serializer) {
+                    this._notebookLogService.info(
+                        "WorkingCopyModel",
+                        "No serializer found for notebook model, checking if provider still needs to be resolved"
+                    );
+                    serializer = await this.getNotebookSerializer().catch(error => {
+                        this._notebookLogService.error("WorkingCopyModel", `Failed to get notebook serializer: ${error}`);
+                        this.save = undefined;
+                        throw ( new NotebookSaveError("Failed to get notebook serializer"));
+                    });
+                }
+                if (token.isCancellationRequested) {
+                    throw ( new CancellationError());
+                }
+                const stat = await serializer.save(this._notebookModel.uri, this._notebookModel.versionId, options, token);
+                return stat;
+            } catch (error) {
+                if (!token.isCancellationRequested && error.name !== "Canceled") {
+                    const isIPynb = this._notebookModel.viewType === "jupyter-notebook" || this._notebookModel.viewType === "interactive";
+                    const errorMessage = getSaveErrorMessage(error);
+                    this._telemetryService.publicLogError2("notebook/SaveError", {
+                        isRemote: this._notebookModel.uri.scheme === Schemas.vscodeRemote,
+                        isIPyNbWorkerSerializer: isIPynb && this._configurationService.getValue("ipynb.experimental.serialization"),
+                        error: errorMessage
+                    });
+                }
+                throw error;
+            }
+        };
+    }
+    dispose() {
+        this._notebookModel.dispose();
+        super.dispose();
+    }
+    get notebookModel() {
+        return this._notebookModel;
+    }
+    async snapshot(context, token) {
+        return this._notebookService.createNotebookTextDocumentSnapshot(this._notebookModel.uri, context, token);
+    }
+    async update(stream, token) {
+        const serializer = await this.getNotebookSerializer();
+        const bytes = await streamToBuffer(stream);
+        const data = await serializer.dataToNotebook(bytes);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        this._notebookLogService.info(
+            "WorkingCopyModel",
+            "Notebook content updated from file system - " + ( this._notebookModel.uri.toString())
+        );
+        this._notebookModel.reset(data.cells, data.metadata, serializer.options);
+    }
+    async getNotebookSerializer() {
+        const info = await this._notebookService.withNotebookDataProvider(this.notebookModel.viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            const message = "CANNOT open notebook with this provider";
+            throw ( new NotebookSaveError(message));
+        }
+        return info.serializer;
+    }
+    get versionId() {
+        return this._notebookModel.alternativeVersionId;
+    }
+    pushStackElement() {
+        this._notebookModel.pushStackElement();
+    }
+}
+let NotebookFileWorkingCopyModelFactory = class NotebookFileWorkingCopyModelFactory {
+    constructor(
+        _viewType,
+        _notebookService,
+        _configurationService,
+        _telemetryService,
+        _notebookLogService
+    ) {
+        this._viewType = _viewType;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+        this._telemetryService = _telemetryService;
+        this._notebookLogService = _notebookLogService;
+    }
+    async createModel(resource, stream, token) {
+        const notebookModel = this._notebookService.getNotebookTextModel(resource) ?? (await this._notebookService.createNotebookTextModel(this._viewType, resource, stream));
+        return ( new NotebookFileWorkingCopyModel(
+            notebookModel,
+            this._notebookService,
+            this._configurationService,
+            this._telemetryService,
+            this._notebookLogService
+        ));
+    }
+};
+NotebookFileWorkingCopyModelFactory = ( __decorate([( __param(1, INotebookService)), ( __param(2, IConfigurationService)), ( __param(3, ITelemetryService)), ( __param(4, INotebookLoggingService))], NotebookFileWorkingCopyModelFactory));
+class NotebookSaveError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NotebookSaveError";
+    }
+}
+function getSaveErrorMessage(error) {
+    if (error.name === "NotebookSaveError") {
+        return error.message;
+    } else if (error instanceof FileOperationError) {
+        switch (error.fileOperationResult) {
+        case FileOperationResult.FILE_IS_DIRECTORY:
+            return "File is a directory";
+        case FileOperationResult.FILE_NOT_FOUND:
+            return "File not found";
+        case FileOperationResult.FILE_NOT_MODIFIED_SINCE:
+            return "File not modified since";
+        case FileOperationResult.FILE_MODIFIED_SINCE:
+            return "File modified since";
+        case FileOperationResult.FILE_MOVE_CONFLICT:
+            return "File move conflict";
+        case FileOperationResult.FILE_WRITE_LOCKED:
+            return "File write locked";
+        case FileOperationResult.FILE_PERMISSION_DENIED:
+            return "File permission denied";
+        case FileOperationResult.FILE_TOO_LARGE:
+            return "File too large";
+        case FileOperationResult.FILE_INVALID_PATH:
+            return "File invalid path";
+        case FileOperationResult.FILE_NOT_DIRECTORY:
+            return "File not directory";
+        case FileOperationResult.FILE_OTHER_ERROR:
+            return "File other error";
+        }
+    }
+    return "Unknown error";
+}
+
+export { NotebookFileWorkingCopyModel, NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -3,7 +3,7 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { NotebookWorkingCopyTypeIdentifier, NotebookSetting, CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
+import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from './notebookEditorModel.js';
 import { ReferenceCollection, DisposableStore, dispose, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { Emitter, AsyncEmitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';

package/vscode/src/vs/workbench/contrib/replNotebook/browser/repl.contribution.js

@@ -35,8 +35,8 @@ import { getReplView } from '@codingame/monaco-vscode-api/vscode/vs/workbench/co
 import { REPL_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug';
 import { InlineChatController } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 import { IInteractiveHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/interactive/browser/interactiveHistoryService.service';
-import { NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
-import { executeIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { executeIcon } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
 import { ReplEditorAccessibleView } from '../../notebook/browser/replEditorAccessibleView.js';
 import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
 import { REPL_EDITOR_ID, NotebookSetting, NotebookWorkingCopyTypeIdentifier, CellKind, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
@@ -232,7 +232,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "repl.focusLastItemExecuted",
-            title: ( localize2(15382, "Focus Most Recent REPL Execution")),
+            title: ( localize2(15602, "Focus Most Recent REPL Execution")),
             category: "REPL",
             menu: {
                 id: MenuId.CommandPalette,
@@ -282,7 +282,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "repl.input.focus",
-            title: ( localize2(15383, "Focus Input Editor")),
+            title: ( localize2(15603, "Focus Input Editor")),
             category: "REPL",
             menu: {
                 id: MenuId.CommandPalette,
@@ -327,7 +327,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "repl.execute",
-            title: ( localize2(15384, "Execute REPL input")),
+            title: ( localize2(15604, "Execute REPL input")),
             category: "REPL",
             keybinding: [{
                 when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals("activeEditor", "workbench.editor.repl")), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorAccessibilityHelp.js

@@ -19,28 +19,28 @@ class ReplEditorInputAccessibilityHelp {
 }
 function getAccessibilityInputHelpText() {
     return [( localize(
-        15386,
+        15606,
         "You are in a REPL Editor Input box which will accept code to be executed in the REPL."
     )), ( localize(
-        15387,
+        15607,
         "The Execute command{0} will evaluate the expression in the input box.",
         "<keybinding:repl.execute>"
     )), ( localize(
-        15388,
+        15608,
         "The setting `accessibility.replEditor.readLastExecutionOutput` controls if output will be automatically read when execution completes."
     )), ( localize(
-        15389,
+        15609,
         "The setting `accessibility.replEditor.autoFocusReplExecution` controls if focus will automatically move to the REPL after executing code."
     )), ( localize(
-        15390,
+        15610,
         "The Focus Last executed command{0} will move focus to the last executed item in the REPL history.",
         "<keybinding:repl.focusLastItemExecuted>"
     )), ( localize(
-        15391,
+        15611,
         "When you run the Open Accessbility View command{0} from this input box, the output from the last execution will be shown in the accessibility view.",
         "<keybinding:editor.action.accessibleView>"
     )), ( localize(
-        15392,
+        15612,
         "The Focus Input Editor command{0} will bring the focus back to this editor.",
         "<keybinding:repl.input.focus>"
     ))].join("\n");
@@ -58,30 +58,30 @@ class ReplEditorHistoryAccessibilityHelp {
 }
 function getAccessibilityHistoryHelpText() {
     return [( localize(
-        15393,
+        15613,
         "You are in a REPL History which is a list of cells that have been executed in the REPL. Each cell has an input, an output, and the cell container."
     )), ( localize(
-        15394,
+        15614,
         "The Edit Cell command{0} will move focus to the read-only editor for the input of the cell.",
         "<keybinding:notebook.cell.edit>"
     )), ( localize(
-        15395,
+        15615,
         "The Quit Edit command{0} will move focus to the cell container, where the up and down arrows will also move focus between cells in the history.",
         "<keybinding:notebook.cell.quitEdit>"
     )), ( localize(
-        15396,
+        15616,
         "Run the Open Accessbility View command{0} while navigating the history for an accessible view of the item's output.",
         "<keybinding:editor.action.accessibleView>"
     )), ( localize(
-        15397,
+        15617,
         "The Focus Output command{0} will set focus on the output when focused on a previously executed item.",
         "<keybinding:notebook.cell.focusInOutput>"
     )), ( localize(
-        15398,
+        15618,
         "The Focus Input Editor command{0} will move focus to the REPL input box.",
         "<keybinding:repl.input.focus>"
     )), ( localize(
-        15390,
+        15610,
         "The Focus Last executed command{0} will move focus to the last executed item in the REPL history.",
         "<keybinding:repl.focusLastItemExecuted>"
     ))].join("\n");

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

@@ -51,10 +51,10 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         FileWorkingCopyManager_1 = this;
     }
     static {
-        this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("fileWorkingCopyCreate.source", ( localize(20054, "File Created")));
+        this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("fileWorkingCopyCreate.source", ( localize(20386, "File Created")));
     }
     static {
-        this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("fileWorkingCopyReplace.source", ( localize(20055, "File Replaced")));
+        this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("fileWorkingCopyReplace.source", ( localize(20387, "File Replaced")));
     }
     constructor(
         workingCopyTypeId,
@@ -133,7 +133,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             constructor(stored) {
                 super();
                 this.stored = stored;
-                this.label = ( localize(20056, "File Working Copy Decorations"));
+                this.label = ( localize(20388, "File Working Copy Decorations"));
                 this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -166,20 +166,20 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(20057, "Deleted, Read-only"))
+                        tooltip: ( localize(20389, "Deleted, Read-only"))
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(20058, "Read-only"))
+                        tooltip: ( localize(20390, "Read-only"))
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(20059, "Deleted"))
+                        tooltip: ( localize(20391, "Deleted"))
                     };
                 }
                 return undefined;
@@ -334,17 +334,17 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         } = await this.dialogService.confirm({
             type: "warning",
             message: ( localize(
-                20060,
+                20392,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                20061,
+                20393,
                 "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: ( localize(20062, "&&Replace"))
+            primaryButton: ( localize(20394, "&&Replace"))
         });
         return confirmed;
     }
@@ -354,12 +354,12 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         } = await this.dialogService.confirm({
             type: "warning",
             message: ( localize(
-                20063,
+                20395,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(20064, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(20065, "&&Save Anyway"))
+            detail: ( localize(20396, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(20397, "&&Save Anyway"))
         });
         return confirmed;
     }

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

@@ -109,7 +109,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
             this._register(
                 this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), {
                     id: "join.fileWorkingCopyManager",
-                    label: ( localize(20083, "Saving working copies"))
+                    label: ( localize(20415, "Saving working copies"))
                 }))
             );
         }