@codingame/monaco-vscode-files-service-override 11.1.2 → 12.0.0

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

@@ -0,0 +1,10 @@
+import { VSBuffer } from "vscode/vscode/vs/base/common/buffer";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IDataTransformer, IErrorTransformer, WriteableStream } from "vscode/vscode/vs/base/common/stream";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IFileReadStreamOptions, IFileSystemProviderWithOpenReadWriteCloseCapability } from "vscode/vscode/vs/platform/files/common/files";
+export interface ICreateReadStreamOptions extends IFileReadStreamOptions {
+    readonly bufferSize: number;
+    readonly errorTransformer?: IErrorTransformer;
+}
+export declare function readFileIntoStream<T>(provider: IFileSystemProviderWithOpenReadWriteCloseCapability, resource: URI, target: WriteableStream<T>, transformer: IDataTransformer<VSBuffer, T>, options: ICreateReadStreamOptions, token: CancellationToken): Promise<void>;

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

@@ -1,3 +1,4 @@
+
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { canceled } from 'vscode/vscode/vs/base/common/errors';
 import { localize } from 'vscode/vscode/vs/nls';
@@ -69,7 +70,7 @@ function throwIfCancelled(token) {
 }
 function throwIfTooLarge(totalBytesRead, options) {
     if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localize(4472, "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        throw createFileSystemProviderError(( localize(1779, "File is too large to open")), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

package/vscode/src/vs/workbench/services/files/browser/elevatedFileService.d.ts

@@ -0,0 +1,9 @@
+import { VSBuffer, VSBufferReadable, VSBufferReadableStream } from "vscode/vscode/vs/base/common/buffer";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IFileStatWithMetadata, IWriteFileOptions } from "vscode/vscode/vs/platform/files/common/files";
+import { IElevatedFileService } from "vscode/vscode/vs/workbench/services/files/common/elevatedFileService.service";
+export declare class BrowserElevatedFileService implements IElevatedFileService {
+    readonly _serviceBrand: undefined;
+    isSupported(resource: URI): boolean;
+    writeFileElevated(resource: URI, value: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;
+}

package/vscode/src/vs/workbench/services/files/browser/elevatedFileService.js

@@ -1,3 +1,5 @@
+
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
 class BrowserElevatedFileService {

package/vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.d.ts

@@ -0,0 +1,24 @@
+import { AbstractTextFileService } from "./textFileService.js";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { ICodeEditorService } from "vscode/vscode/vs/editor/browser/services/codeEditorService";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { ITextResourceConfigurationService } from "vscode/vscode/vs/editor/common/services/textResourceConfiguration";
+import { IFileDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IElevatedFileService } from "vscode/vscode/vs/workbench/services/files/common/elevatedFileService.service";
+import { IFilesConfigurationService } from "vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IPathService } from "vscode/vscode/vs/workbench/services/path/common/pathService.service";
+import { IUntitledTextEditorService } from "vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IDecorationsService } from "vscode/vscode/vs/workbench/services/decorations/common/decorations.service";
+export declare class BrowserTextFileService extends AbstractTextFileService {
+    constructor(fileService: IFileService, untitledTextEditorService: IUntitledTextEditorService, lifecycleService: ILifecycleService, instantiationService: IInstantiationService, modelService: IModelService, environmentService: IWorkbenchEnvironmentService, dialogService: IDialogService, fileDialogService: IFileDialogService, textResourceConfigurationService: ITextResourceConfigurationService, filesConfigurationService: IFilesConfigurationService, codeEditorService: ICodeEditorService, pathService: IPathService, workingCopyFileService: IWorkingCopyFileService, uriIdentityService: IUriIdentityService, languageService: ILanguageService, elevatedFileService: IElevatedFileService, logService: ILogService, decorationsService: IDecorationsService);
+    private registerListeners;
+    private onBeforeShutdown;
+}

package/vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.js

@@ -1,6 +1,9 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { AbstractTextFileService } from './textFileService.js';
+import { TextFileEditorModelState } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
@@ -27,7 +30,7 @@ let BrowserTextFileService = class BrowserTextFileService extends AbstractTextFi
         this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles')));
     }
     onBeforeShutdown() {
-        if (( this.files.models.some(model => model.hasState(2 )))) {
+        if (( this.files.models.some(model => model.hasState(TextFileEditorModelState.PENDING_SAVE)))) {
             return true;
         }
         return false;

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.d.ts

@@ -0,0 +1,111 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ITextFileStreamContent, ITextFileContent, IResourceEncodings, IReadTextFileOptions, IWriteTextFileOptions, ITextFileSaveOptions, ITextFileEditorModelManager, IResourceEncoding, ITextFileSaveAsOptions, IReadTextFileEncodingOptions } from "vscode/vscode/vs/workbench/services/textfile/common/textfiles";
+import { ITextFileService } from "vscode/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { IRevertOptions } from "vscode/vscode/vs/workbench/common/editor";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IFileStatWithMetadata, ICreateFileOptions } from "vscode/vscode/vs/platform/files/common/files";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IUntitledTextEditorModelManager } from "@codingame/monaco-vscode-view-common-service-override/vscode/vs/workbench/services/untitled/common/untitledTextEditorService";
+import { IUntitledTextEditorService } from "vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { IFileDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { VSBuffer, VSBufferReadable, VSBufferReadableStream } from "vscode/vscode/vs/base/common/buffer";
+import { ITextSnapshot } from "vscode/vscode/vs/editor/common/model";
+import { ITextResourceConfigurationService } from "vscode/vscode/vs/editor/common/services/textResourceConfiguration";
+import { IFilesConfigurationService } from "vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { ICodeEditorService } from "vscode/vscode/vs/editor/browser/services/codeEditorService";
+import { IPathService } from "vscode/vscode/vs/workbench/services/path/common/pathService.service";
+import { IFileOperationUndoRedoInfo } from "@codingame/monaco-vscode-base-service-override/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { ReadableStream } from "vscode/vscode/vs/base/common/stream";
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IElevatedFileService } from "vscode/vscode/vs/workbench/services/files/common/elevatedFileService.service";
+import { IDecorationsService } from "vscode/vscode/vs/workbench/services/decorations/common/decorations.service";
+export declare abstract class AbstractTextFileService extends Disposable implements ITextFileService {
+    protected readonly fileService: IFileService;
+    private untitledTextEditorService;
+    protected readonly lifecycleService: ILifecycleService;
+    protected readonly instantiationService: IInstantiationService;
+    private readonly modelService;
+    protected readonly environmentService: IWorkbenchEnvironmentService;
+    private readonly dialogService;
+    private readonly fileDialogService;
+    protected readonly textResourceConfigurationService: ITextResourceConfigurationService;
+    protected readonly filesConfigurationService: IFilesConfigurationService;
+    private readonly codeEditorService;
+    private readonly pathService;
+    private readonly workingCopyFileService;
+    private readonly uriIdentityService;
+    private readonly languageService;
+    protected readonly logService: ILogService;
+    private readonly elevatedFileService;
+    private readonly decorationsService;
+    readonly _serviceBrand: undefined;
+    private static readonly TEXTFILE_SAVE_CREATE_SOURCE;
+    private static readonly TEXTFILE_SAVE_REPLACE_SOURCE;
+    readonly files: ITextFileEditorModelManager;
+    readonly untitled: IUntitledTextEditorModelManager;
+    constructor(fileService: IFileService, untitledTextEditorService: IUntitledTextEditorService, lifecycleService: ILifecycleService, instantiationService: IInstantiationService, modelService: IModelService, environmentService: IWorkbenchEnvironmentService, dialogService: IDialogService, fileDialogService: IFileDialogService, textResourceConfigurationService: ITextResourceConfigurationService, filesConfigurationService: IFilesConfigurationService, codeEditorService: ICodeEditorService, pathService: IPathService, workingCopyFileService: IWorkingCopyFileService, uriIdentityService: IUriIdentityService, languageService: ILanguageService, logService: ILogService, elevatedFileService: IElevatedFileService, decorationsService: IDecorationsService);
+    private provideDecorations;
+    private _encoding;
+    get encoding(): EncodingOracle;
+    read(resource: URI, options?: IReadTextFileOptions): Promise<ITextFileContent>;
+    readStream(resource: URI, options?: IReadTextFileOptions): Promise<ITextFileStreamContent>;
+    private doRead;
+    create(operations: {
+        resource: URI;
+        value?: string | ITextSnapshot;
+        options?: ICreateFileOptions;
+    }[], undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
+    write(resource: URI, value: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<IFileStatWithMetadata>;
+    getEncodedReadable(resource: URI, value: ITextSnapshot): Promise<VSBufferReadable>;
+    getEncodedReadable(resource: URI, value: string): Promise<VSBuffer>;
+    getEncodedReadable(resource: URI, value?: ITextSnapshot): Promise<VSBufferReadable | undefined>;
+    getEncodedReadable(resource: URI, value?: string): Promise<VSBuffer | undefined>;
+    getEncodedReadable(resource: URI, value?: string | ITextSnapshot): Promise<VSBuffer | VSBufferReadable | undefined>;
+    getEncodedReadable(resource: URI, value: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable>;
+    getDecodedStream(resource: URI, value: VSBufferReadableStream, options?: IReadTextFileEncodingOptions): Promise<ReadableStream<string>>;
+    private doGetDecodedStream;
+    save(resource: URI, options?: ITextFileSaveOptions): Promise<URI | undefined>;
+    saveAs(source: URI, target?: URI, options?: ITextFileSaveAsOptions): Promise<URI | undefined>;
+    private doSaveAs;
+    private doSaveAsTextFile;
+    private confirmOverwrite;
+    private confirmMakeWriteable;
+    private suggestSavePath;
+    suggestFilename(languageId: string, untitledName: string): string;
+    revert(resource: URI, options?: IRevertOptions): Promise<void>;
+    isDirty(resource: URI): boolean;
+}
+export interface IEncodingOverride {
+    parent?: URI;
+    extension?: string;
+    encoding: string;
+}
+export declare class EncodingOracle extends Disposable implements IResourceEncodings {
+    private textResourceConfigurationService;
+    private environmentService;
+    private contextService;
+    private readonly uriIdentityService;
+    private _encodingOverrides;
+    protected get encodingOverrides(): IEncodingOverride[];
+    protected set encodingOverrides(value: IEncodingOverride[]);
+    constructor(textResourceConfigurationService: ITextResourceConfigurationService, environmentService: IWorkbenchEnvironmentService, contextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService);
+    private registerListeners;
+    private getDefaultEncodingOverrides;
+    getWriteEncoding(resource: URI, options?: IWriteTextFileOptions): Promise<{
+        encoding: string;
+        addBOM: boolean;
+    }>;
+    getPreferredWriteEncoding(resource: URI, preferredEncoding?: string): Promise<IResourceEncoding>;
+    getPreferredReadEncoding(resource: URI, options?: IReadTextFileEncodingOptions, detectedEncoding?: string): Promise<IResourceEncoding>;
+    private getEncodingForResource;
+    private getEncodingOverride;
+}

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -1,14 +1,16 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
-import { TextFileOperationError, toBufferOrReadable, stringToSnapshot } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { TextFileEditorModelState, TextFileOperationError, TextFileOperationResult, toBufferOrReadable, stringToSnapshot } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
 import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { FileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { extname } from 'vscode/vscode/vs/base/common/path';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IUntitledTextEditorService } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service';
-import { UntitledTextEditorModel } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel';
+import { UntitledTextEditorModel } from '@codingame/monaco-vscode-0c06bfba-d24d-5c4d-90cd-b40cefb7f811-common/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel';
 import { TextFileEditorModelManager } from '../common/textFileEditorModelManager.js';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
@@ -20,14 +22,14 @@ import { bufferToStream } from 'vscode/vscode/vs/base/common/buffer';
 import { ITextResourceConfigurationService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
 import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
 import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
-import { BaseTextEditorModel } from 'vscode/vscode/vs/workbench/common/editor/textEditorModel';
+import { BaseTextEditorModel } from '@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/workbench/common/editor/textEditorModel';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { WORKSPACE_EXTENSION } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { UTF8, toEncodeReadable, toDecodeStream, UTF16be, UTF16le, UTF8_with_bom, encodingExists } from 'vscode/vscode/vs/workbench/services/textfile/common/encoding';
+import { UTF8, DecodeStreamErrorKind, toEncodeReadable, toDecodeStream, UTF16be, UTF16le, UTF8_with_bom, encodingExists } from '@codingame/monaco-vscode-2e67e044-0db9-5fa6-8bd1-3737a7d586d4-common/vscode/vs/workbench/services/textfile/common/encoding';
 import { consumeStream } from 'vscode/vscode/vs/base/common/stream';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -51,8 +53,8 @@ import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 var AbstractTextFileService_1;
 let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     static { AbstractTextFileService_1 = this; }
-    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize(4474, "File Created"))); }
-    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize(4475, "File Replaced"))); }
+    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize(11758, "File Created"))); }
+    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize(11759, "File Replaced"))); }
     constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService) {
         super();
         this.fileService = fileService;
@@ -82,14 +84,14 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localize(4476, "Text File Model Decorations"));
-                this._onDidChange = this._register(( (new Emitter())));
+                this.label = ( localize(11760, "Text File Model Decorations"));
+                this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
             }
             registerListeners() {
                 this._register(this.files.onDidResolve(({ model }) => {
-                    if (model.isReadonly() || model.hasState(4 )) {
+                    if (model.isReadonly() || model.hasState(TextFileEditorModelState.ORPHAN)) {
                         this._onDidChange.fire([model.resource]);
                     }
                 }));
@@ -103,26 +105,26 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                     return undefined;
                 }
                 const isReadonly = model.isReadonly();
-                const isOrphaned = model.hasState(4 );
+                const isOrphaned = model.hasState(TextFileEditorModelState.ORPHAN);
                 if (isReadonly && isOrphaned) {
                     return {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(4477, "Deleted, Read-only")),
+                        tooltip: ( localize(11761, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(4478, "Read-only")),
+                        tooltip: ( localize(11762, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(4479, "Deleted")),
+                        tooltip: ( localize(11763, "Deleted")),
                     };
                 }
                 return undefined;
@@ -156,7 +158,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         };
     }
     async doRead(resource, options) {
-        const cts = ( (new CancellationTokenSource()));
+        const cts = ( new CancellationTokenSource());
         let bufferStream;
         if (options?.preferUnbuffered) {
             const content = await this.fileService.readFile(resource, options, cts.token);
@@ -174,12 +176,8 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
         catch (error) {
             cts.dispose(true);
-            if (error.decodeStreamErrorKind === 1 ) {
-                throw ( (new TextFileOperationError(
-                    localize(4480, "File seems to be binary and cannot be opened as text"),
-                    0 ,
-                    options
-                )));
+            if (error.decodeStreamErrorKind === DecodeStreamErrorKind.STREAM_IS_BINARY) {
+                throw ( new TextFileOperationError(( localize(11764, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
             }
             else {
                 throw error;
@@ -187,14 +185,14 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
     }
     async create(operations, undoInfo) {
-        const operationsWithContents = await Promise.all(( (operations.map(async (operation) => {
+        const operationsWithContents = await Promise.all(( operations.map(async (operation) => {
             const contents = await this.getEncodedReadable(operation.resource, operation.value);
             return {
                 resource: operation.resource,
                 contents,
                 overwrite: operation.options?.overwrite
             };
-        }))));
+        })));
         return this.workingCopyFileService.create(operationsWithContents, CancellationToken.None, undoInfo);
     }
     async write(resource, value, options) {
@@ -332,8 +330,8 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             }
             catch (error) {
                 if (targetExists) {
-                    if (error.textFileOperationResult === 0  ||
-                        error.fileOperationResult === 7 ) {
+                    if (error.textFileOperationResult === TextFileOperationResult.FILE_IS_BINARY ||
+                        error.fileOperationResult === FileOperationResult.FILE_TOO_LARGE) {
                         await this.fileService.del(target);
                         return this.doSaveAsTextFile(sourceModel, source, target, options);
                     }
@@ -394,17 +392,17 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                4481,
+                11765,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                4482,
+                11766,
                 "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(4483, "&&Replace")),
+            primaryButton: ( localize(11767, "&&Replace")),
         });
         return confirmed;
     }
@@ -412,12 +410,12 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                4484,
+                11768,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(4485, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(4486, "&&Save Anyway"))
+            detail: ( localize(11769, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(11770, "&&Save Anyway"))
         });
         return confirmed;
     }
@@ -500,26 +498,26 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         return false;
     }
 };
-AbstractTextFileService = AbstractTextFileService_1 = ( (__decorate([
-    ( (__param(0, IFileService))),
-    ( (__param(1, IUntitledTextEditorService))),
-    ( (__param(2, ILifecycleService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IModelService))),
-    ( (__param(5, IWorkbenchEnvironmentService))),
-    ( (__param(6, IDialogService))),
-    ( (__param(7, IFileDialogService))),
-    ( (__param(8, ITextResourceConfigurationService))),
-    ( (__param(9, IFilesConfigurationService))),
-    ( (__param(10, ICodeEditorService))),
-    ( (__param(11, IPathService))),
-    ( (__param(12, IWorkingCopyFileService))),
-    ( (__param(13, IUriIdentityService))),
-    ( (__param(14, ILanguageService))),
-    ( (__param(15, ILogService))),
-    ( (__param(16, IElevatedFileService))),
-    ( (__param(17, IDecorationsService)))
-], AbstractTextFileService)));
+AbstractTextFileService = AbstractTextFileService_1 = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUntitledTextEditorService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IModelService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IDialogService)),
+    ( __param(7, IFileDialogService)),
+    ( __param(8, ITextResourceConfigurationService)),
+    ( __param(9, IFilesConfigurationService)),
+    ( __param(10, ICodeEditorService)),
+    ( __param(11, IPathService)),
+    ( __param(12, IWorkingCopyFileService)),
+    ( __param(13, IUriIdentityService)),
+    ( __param(14, ILanguageService)),
+    ( __param(15, ILogService)),
+    ( __param(16, IElevatedFileService)),
+    ( __param(17, IDecorationsService))
+], AbstractTextFileService));
 let EncodingOracle = class EncodingOracle extends Disposable {
     get encodingOverrides() { return this._encodingOverrides; }
     set encodingOverrides(value) { this._encodingOverrides = value; }
@@ -611,11 +609,11 @@ let EncodingOracle = class EncodingOracle extends Disposable {
         return undefined;
     }
 };
-EncodingOracle = ( (__decorate([
-    ( (__param(0, ITextResourceConfigurationService))),
-    ( (__param(1, IWorkbenchEnvironmentService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IUriIdentityService)))
-], EncodingOracle)));
+EncodingOracle = ( __decorate([
+    ( __param(0, ITextResourceConfigurationService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IUriIdentityService))
+], EncodingOracle));
 
 export { AbstractTextFileService, EncodingOracle };

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.d.ts

@@ -0,0 +1,76 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { TextFileEditorModel } from "@codingame/monaco-vscode-0c06bfba-d24d-5c4d-90cd-b40cefb7f811-common/vscode/vs/workbench/services/textfile/common/textFileEditorModel";
+import { IDisposable, Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ITextFileEditorModel, ITextFileEditorModelManager, ITextFileEditorModelResolveOrCreateOptions, ITextFileResolveEvent, ITextFileSaveEvent, ITextFileSaveParticipant } from "vscode/vscode/vs/workbench/services/textfile/common/textfiles";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IStoredFileWorkingCopySaveParticipantContext } from "@codingame/monaco-vscode-base-service-override/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IProgress, IProgressStep } from "vscode/vscode/vs/platform/progress/common/progress";
+export declare class TextFileEditorModelManager extends Disposable implements ITextFileEditorModelManager {
+    private readonly instantiationService;
+    private readonly fileService;
+    private readonly notificationService;
+    private readonly workingCopyFileService;
+    private readonly uriIdentityService;
+    private readonly _onDidCreate;
+    readonly onDidCreate: Event<TextFileEditorModel>;
+    private readonly _onDidResolve;
+    readonly onDidResolve: Event<ITextFileResolveEvent>;
+    private readonly _onDidRemove;
+    readonly onDidRemove: Event<URI>;
+    private readonly _onDidChangeDirty;
+    readonly onDidChangeDirty: Event<TextFileEditorModel>;
+    private readonly _onDidChangeReadonly;
+    readonly onDidChangeReadonly: Event<TextFileEditorModel>;
+    private readonly _onDidChangeOrphaned;
+    readonly onDidChangeOrphaned: Event<TextFileEditorModel>;
+    private readonly _onDidSaveError;
+    readonly onDidSaveError: Event<TextFileEditorModel>;
+    private readonly _onDidSave;
+    readonly onDidSave: Event<ITextFileSaveEvent>;
+    private readonly _onDidRevert;
+    readonly onDidRevert: Event<TextFileEditorModel>;
+    private readonly _onDidChangeEncoding;
+    readonly onDidChangeEncoding: Event<TextFileEditorModel>;
+    private readonly mapResourceToModel;
+    private readonly mapResourceToModelListeners;
+    private readonly mapResourceToDisposeListener;
+    private readonly mapResourceToPendingModelResolvers;
+    private readonly modelResolveQueue;
+    saveErrorHandler: {
+        onSaveError(error: Error, model: ITextFileEditorModel): void;
+    };
+    get models(): TextFileEditorModel[];
+    constructor(instantiationService: IInstantiationService, fileService: IFileService, notificationService: INotificationService, workingCopyFileService: IWorkingCopyFileService, uriIdentityService: IUriIdentityService);
+    private registerListeners;
+    private onDidFilesChange;
+    private onDidChangeFileSystemProviderCapabilities;
+    private onDidChangeFileSystemProviderRegistrations;
+    private queueModelReloads;
+    private queueModelReload;
+    private readonly mapCorrelationIdToModelsToRestore;
+    private onWillRunWorkingCopyFileOperation;
+    private onDidFailWorkingCopyFileOperation;
+    private onDidRunWorkingCopyFileOperation;
+    get(resource: URI): TextFileEditorModel | undefined;
+    private has;
+    private reload;
+    resolve(resource: URI, options?: ITextFileEditorModelResolveOrCreateOptions): Promise<TextFileEditorModel>;
+    private doResolve;
+    private joinPendingResolves;
+    private doJoinPendingResolves;
+    private registerModel;
+    add(resource: URI, model: TextFileEditorModel): void;
+    remove(resource: URI): void;
+    private readonly saveParticipants;
+    addSaveParticipant(participant: ITextFileSaveParticipant): IDisposable;
+    runSaveParticipants(model: ITextFileEditorModel, context: IStoredFileWorkingCopySaveParticipantContext, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+    canDispose(model: TextFileEditorModel): true | Promise<true>;
+    private doCanDispose;
+    dispose(): void;
+}