@codingame/monaco-vscode-files-service-override 4.5.0 → 4.5.2

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

@@ -3,6 +3,7 @@ import { canceled } from 'vscode/vscode/vs/base/common/errors';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
 
+const _moduleId = "vs/platform/files/common/io";
 async function readFileIntoStream(provider, resource, target, transformer, options, token) {
     let error = undefined;
     try {
@@ -69,7 +70,7 @@ function throwIfCancelled(token) {
 }
 function throwIfTooLarge(totalBytesRead, options) {
     if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localizeWithPath('vs/platform/files/common/io', 'fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        throw createFileSystemProviderError(localizeWithPath(_moduleId, 0, "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

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

@@ -5,7 +5,7 @@ class BrowserElevatedFileService {
         return false;
     }
     async writeFileElevated(resource, value, options) {
-        throw new Error('Unsupported');
+        throw ( new Error('Unsupported'));
     }
 }
 

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

@@ -50,18 +50,11 @@ import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 
 var AbstractTextFileService_1;
+const _moduleId = "vs/workbench/services/textfile/browser/textFileService";
 let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     static { AbstractTextFileService_1 = this; }
-    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localizeWithPath(
-        'vs/workbench/services/textfile/browser/textFileService',
-        'textFileCreate.source',
-        "File Created"
-    ))); }
-    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localizeWithPath(
-        'vs/workbench/services/textfile/browser/textFileService',
-        'textFileOverwrite.source',
-        "File Replaced"
-    ))); }
+    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localizeWithPath(_moduleId, 0, "File Created"))); }
+    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localizeWithPath(_moduleId, 1, "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;
@@ -91,12 +84,8 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localizeWithPath(
-                    'vs/workbench/services/textfile/browser/textFileService',
-                    'textFileModelDecorations',
-                    "Text File Model Decorations"
-                ));
-                this._onDidChange = this._register(( new Emitter()));
+                this.label = ( localizeWithPath(_moduleId, 2, "Text File Model Decorations"));
+                this._onDidChange = this._register(( (new Emitter())));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
             }
@@ -122,32 +111,20 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localizeWithPath(
-                            'vs/workbench/services/textfile/browser/textFileService',
-                            'readonlyAndDeleted',
-                            "Deleted, Read-only"
-                        )),
+                        tooltip: ( localizeWithPath(_moduleId, 3, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localizeWithPath(
-                            'vs/workbench/services/textfile/browser/textFileService',
-                            'readonly',
-                            "Read-only"
-                        )),
+                        tooltip: ( localizeWithPath(_moduleId, 4, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localizeWithPath(
-                            'vs/workbench/services/textfile/browser/textFileService',
-                            'deleted',
-                            "Deleted"
-                        )),
+                        tooltip: ( localizeWithPath(_moduleId, 5, "Deleted")),
                     };
                 }
                 return undefined;
@@ -181,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);
@@ -200,7 +177,11 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         catch (error) {
             cts.dispose(true);
             if (error.decodeStreamErrorKind === 1 ) {
-                throw new TextFileOperationError(localizeWithPath('vs/workbench/services/textfile/browser/textFileService', 'fileBinaryError', "File seems to be binary and cannot be opened as text"), 0 , options);
+                throw ( (new TextFileOperationError(
+                    localizeWithPath(_moduleId, 6, "File seems to be binary and cannot be opened as text"),
+                    0 ,
+                    options
+                )));
             }
             else {
                 throw error;
@@ -208,14 +189,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) {
@@ -412,23 +393,19 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localizeWithPath(
-                'vs/workbench/services/textfile/browser/textFileService',
-                'confirmOverwrite',
+                _moduleId,
+                7,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localizeWithPath(
-                'vs/workbench/services/textfile/browser/textFileService',
-                'overwriteIrreversible',
+                _moduleId,
+                8,
                 "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/textfile/browser/textFileService',
-                { key: 'replaceButtonLabel', comment: ['&& denotes a mnemonic'] },
-                "&&Replace"
-            )),
+            primaryButton: ( localizeWithPath(_moduleId, 9, "&&Replace")),
         });
         return confirmed;
     }
@@ -436,21 +413,13 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localizeWithPath(
-                'vs/workbench/services/textfile/browser/textFileService',
-                'confirmMakeWriteable',
+                _moduleId,
+                10,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localizeWithPath(
-                'vs/workbench/services/textfile/browser/textFileService',
-                'confirmMakeWriteableDetail',
-                "Paths can be configured as read-only via settings."
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/services/textfile/browser/textFileService',
-                { key: 'makeWriteableButtonLabel', comment: ['&& denotes a mnemonic'] },
-                "&&Save Anyway"
-            ))
+            detail: ( localizeWithPath(_moduleId, 11, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localizeWithPath(_moduleId, 12, "&&Save Anyway"))
         });
         return confirmed;
     }
@@ -533,26 +502,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; }
@@ -644,11 +613,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.js

@@ -18,9 +18,10 @@ import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/com
 import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 
+const _moduleId = "vs/workbench/services/textfile/common/textFileEditorModelManager";
 let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
     get models() {
-        return [...( this.mapResourceToModel.values())];
+        return [...( (this.mapResourceToModel.values()))];
     }
     constructor(instantiationService, fileService, notificationService, workingCopyFileService, uriIdentityService) {
         super();
@@ -29,38 +30,38 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
         this.notificationService = notificationService;
         this.workingCopyFileService = workingCopyFileService;
         this.uriIdentityService = uriIdentityService;
-        this._onDidCreate = this._register(( new Emitter()));
+        this._onDidCreate = this._register(( (new Emitter())));
         this.onDidCreate = this._onDidCreate.event;
-        this._onDidResolve = this._register(( new Emitter()));
+        this._onDidResolve = this._register(( (new Emitter())));
         this.onDidResolve = this._onDidResolve.event;
-        this._onDidRemove = this._register(( new Emitter()));
+        this._onDidRemove = this._register(( (new Emitter())));
         this.onDidRemove = this._onDidRemove.event;
-        this._onDidChangeDirty = this._register(( new Emitter()));
+        this._onDidChangeDirty = this._register(( (new Emitter())));
         this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this._onDidChangeReadonly = this._register(( (new Emitter())));
         this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this._onDidChangeOrphaned = this._register(( (new Emitter())));
         this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidSaveError = this._register(( new Emitter()));
+        this._onDidSaveError = this._register(( (new Emitter())));
         this.onDidSaveError = this._onDidSaveError.event;
-        this._onDidSave = this._register(( new Emitter()));
+        this._onDidSave = this._register(( (new Emitter())));
         this.onDidSave = this._onDidSave.event;
-        this._onDidRevert = this._register(( new Emitter()));
+        this._onDidRevert = this._register(( (new Emitter())));
         this.onDidRevert = this._onDidRevert.event;
-        this._onDidChangeEncoding = this._register(( new Emitter()));
+        this._onDidChangeEncoding = this._register(( (new Emitter())));
         this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this.mapResourceToModel = ( new ResourceMap());
-        this.mapResourceToModelListeners = ( new ResourceMap());
-        this.mapResourceToDisposeListener = ( new ResourceMap());
-        this.mapResourceToPendingModelResolvers = ( new ResourceMap());
-        this.modelResolveQueue = this._register(( new ResourceQueue()));
+        this.mapResourceToModel = ( (new ResourceMap()));
+        this.mapResourceToModelListeners = ( (new ResourceMap()));
+        this.mapResourceToDisposeListener = ( (new ResourceMap()));
+        this.mapResourceToPendingModelResolvers = ( (new ResourceMap()));
+        this.modelResolveQueue = this._register(( (new ResourceQueue())));
         this.saveErrorHandler = (() => {
             const notificationService = this.notificationService;
             return {
                 onSaveError(error, model) {
                     notificationService.error(( localizeWithPath(
-                        'vs/workbench/services/textfile/common/textFileEditorModelManager',
-                        { key: 'genericSaveError', comment: ['{0} is the resource that failed to save and {1} the error message'] },
+                        _moduleId,
+                        0,
                         "Failed to save '{0}': {1}",
                         model.name,
                         toErrorMessage(error, false)
@@ -68,7 +69,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
                 }
             };
         })();
-        this.mapCorrelationIdToModelsToRestore = ( new Map());
+        this.mapCorrelationIdToModelsToRestore = ( (new Map()));
         this.saveParticipants = this._register(this.instantiationService.createInstance(TextFileSaveParticipant));
         this.registerListeners();
     }
@@ -189,7 +190,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
                     const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
                     if (modelsToRestore) {
                         this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
-                        await Promises.settled(( modelsToRestore.map(async (modelToRestore) => {
+                        await Promises.settled(( (modelsToRestore.map(async (modelToRestore) => {
                             const restoredModel = await this.resolve(modelToRestore.target, {
                                 reload: { async: false },
                                 contents: modelToRestore.snapshot ? createTextBufferFactoryFromSnapshot(modelToRestore.snapshot) : undefined,
@@ -201,7 +202,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
                                 extname(modelToRestore.target) !== PLAINTEXT_EXTENSION) {
                                 restoredModel.updateTextEditorModel(undefined, modelToRestore.languageId);
                             }
-                        })));
+                        }))));
                     }
                 })());
                 break;
@@ -211,11 +212,13 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
         return this.mapResourceToModel.get(resource);
     }
     has(resource) {
-        return ( this.mapResourceToModel.has(resource));
+        return (
+             (this.mapResourceToModel.has(resource))
+        );
     }
     async reload(model) {
         await this.joinPendingResolves(model.resource);
-        if (model.isDirty() || model.isDisposed() || !( this.has(model.resource))) {
+        if (model.isDirty() || model.isDisposed() || !( (this.has(model.resource)))) {
             return;
         }
         await this.doResolve(model, { reload: { async: false } });
@@ -307,7 +310,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
     }
     async doJoinPendingResolves(resource) {
         let currentModelCopyResolve;
-        while (( this.mapResourceToPendingModelResolvers.has(resource))) {
+        while (( (this.mapResourceToPendingModelResolvers.has(resource)))) {
             const nextPendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
             if (nextPendingModelResolve === currentModelCopyResolve) {
                 return;
@@ -321,7 +324,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
         }
     }
     registerModel(model) {
-        const modelListeners = ( new DisposableStore());
+        const modelListeners = ( (new DisposableStore()));
         modelListeners.add(model.onDidResolve(reason => this._onDidResolve.fire({ model, reason })));
         modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
         modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(model)));
@@ -366,7 +369,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
     }
     canDispose(model) {
         if (model.isDisposed() ||
-            (!( this.mapResourceToPendingModelResolvers.has(model.resource)) && !model.isDirty())) {
+            (!( (this.mapResourceToPendingModelResolvers.has(model.resource))) && !model.isDirty())) {
             return true;
         }
         return this.doCanDispose(model);
@@ -387,18 +390,18 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
         super.dispose();
         this.mapResourceToModel.clear();
         this.mapResourceToPendingModelResolvers.clear();
-        dispose(( this.mapResourceToDisposeListener.values()));
+        dispose(( (this.mapResourceToDisposeListener.values())));
         this.mapResourceToDisposeListener.clear();
-        dispose(( this.mapResourceToModelListeners.values()));
+        dispose(( (this.mapResourceToModelListeners.values())));
         this.mapResourceToModelListeners.clear();
     }
 };
-TextFileEditorModelManager = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IFileService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IWorkingCopyFileService)),
-    ( __param(4, IUriIdentityService))
-], TextFileEditorModelManager));
+TextFileEditorModelManager = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IFileService))),
+    ( (__param(2, INotificationService))),
+    ( (__param(3, IWorkingCopyFileService))),
+    ( (__param(4, IUriIdentityService)))
+], TextFileEditorModelManager)));
 
 export { TextFileEditorModelManager };

package/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -7,6 +7,7 @@ import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/prog
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { insert } from 'vscode/vscode/vs/base/common/arrays';
 
+const _moduleId = "vs/workbench/services/textfile/common/textFileSaveParticipant";
 let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
     constructor(progressService, logService) {
         super();
@@ -19,14 +20,9 @@ let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
         return toDisposable(() => remove());
     }
     participate(model, context, token) {
-        const cts = ( new CancellationTokenSource(token));
+        const cts = ( (new CancellationTokenSource(token)));
         return this.progressService.withProgress({
-            title: ( localizeWithPath(
-                'vs/workbench/services/textfile/common/textFileSaveParticipant',
-                'saveParticipants',
-                "Saving '{0}'",
-                model.name
-            )),
+            title: ( localizeWithPath(_moduleId, 0, "Saving '{0}'", model.name)),
             location: 15 ,
             cancellable: true,
             delay: model.isDirty() ? 3000 : 5000
@@ -56,9 +52,9 @@ let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
         super.dispose();
     }
 };
-TextFileSaveParticipant = ( __decorate([
-    ( __param(0, IProgressService)),
-    ( __param(1, ILogService))
-], TextFileSaveParticipant));
+TextFileSaveParticipant = ( (__decorate([
+    ( (__param(0, IProgressService))),
+    ( (__param(1, ILogService)))
+], TextFileSaveParticipant)));
 
 export { TextFileSaveParticipant };

package/files.d.ts

@@ -1,161 +0,0 @@
-import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { FileType, IStat, IFileSystemProviderWithFileReadWriteCapability, IFileChange, IWatchOptions, IFileWriteOptions, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, FileSystemProviderCapabilities, FileChangeType } from 'vscode/vscode/vs/platform/files/common/files';
-export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions } from 'vscode/vscode/vs/platform/files/common/files';
-import { IndexedDBFileSystemProvider } from './vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
-
-declare abstract class RegisteredFile {
-    uri: URI;
-    private readonly;
-    protected ctime: number;
-    protected mtime: number;
-    readonly type: FileType;
-    protected _onDidChange: Emitter<void>;
-    onDidChange: Event<void>;
-    protected _onDidDelete: Emitter<void>;
-    onDidDelete: Event<void>;
-    protected _onDidRename: Emitter<{
-        from: URI;
-        to: URI;
-    }>;
-    onDidRename: Event<{
-        from: URI;
-        to: URI;
-    }>;
-    constructor(uri: URI, readonly: boolean);
-    stats(): Promise<IStat>;
-    getSize(): Promise<number>;
-    abstract read(): Promise<string | Uint8Array>;
-    abstract write(content: string): Promise<void>;
-    delete(): Promise<void>;
-    rename(to: URI): Promise<void>;
-}
-declare class RegisteredReadOnlyFile extends RegisteredFile {
-    read: () => Promise<string | Uint8Array>;
-    constructor(uri: URI, read: () => Promise<string | Uint8Array>);
-    write(): Promise<void>;
-    delete(): Promise<void>;
-    rename(): Promise<void>;
-}
-declare class RegisteredMemoryFile extends RegisteredFile {
-    private content;
-    constructor(uri: URI, content: string);
-    read(): Promise<string | Uint8Array>;
-    write(content: string): Promise<void>;
-}
-declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
-    private files;
-    capabilities: number;
-    constructor(readonly: boolean);
-    onDidChangeCapabilities: Event<any>;
-    _onDidChangeFile: Emitter<readonly IFileChange[]>;
-    onDidChangeFile: Event<readonly IFileChange[]>;
-    registerFile(file: RegisteredFile): IDisposable;
-    stat(resource: URI): Promise<IStat>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    readFile(resource: URI): Promise<Uint8Array>;
-    watch(): IDisposable;
-    writeFile(resource: URI, content: Uint8Array): Promise<void>;
-    delete(resource: URI): Promise<void>;
-    rename(from: URI, to: URI): Promise<void>;
-    mkdir(): Promise<never>;
-}
-declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
-    private providers;
-    register(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
-    get delegates(): IFileSystemProviderWithFileReadWriteCapability[];
-    onDidChangeCapabilities: Event<any>;
-    _onDidChangeFile: Emitter<readonly IFileChange[]>;
-    onDidChangeFile: Event<readonly IFileChange[]>;
-    _onDidChangeOverlays: Emitter<void>;
-    onDidChangeOverlays: Event<void>;
-    capabilities: number;
-    private readFromDelegates;
-    private writeToDelegates;
-    stat(resource: URI): Promise<IStat>;
-    readFile(resource: URI): Promise<Uint8Array>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    watch(resource: URI, opts: IWatchOptions): IDisposable;
-    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
-    mkdir(resource: URI): Promise<void>;
-    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
-    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
-}
-declare class DelegateFileSystemProvider implements IFileSystemProvider {
-    private options;
-    constructor(options: {
-        delegate: IFileSystemProvider;
-        toDelegate: (uri: URI) => URI;
-        fromDeletate: (uri: URI) => URI;
-    });
-    get capabilities(): FileSystemProviderCapabilities;
-    onDidChangeCapabilities: Event<void>;
-    onDidChangeFile: Event<{
-        type: FileChangeType;
-        resource: URI;
-    }[]>;
-    readFile: ((resource: URI) => Promise<Uint8Array>) | undefined;
-    writeFile: ((resource: URI, content: Uint8Array, opts: IFileWriteOptions) => Promise<void>) | undefined;
-    watch(resource: URI, opts: IWatchOptions): IDisposable;
-    stat(resource: URI): Promise<IStat>;
-    mkdir(resource: URI): Promise<void>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
-    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
-}
-declare class EmptyFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
-    readFile(): Promise<Uint8Array>;
-    writeFile(): Promise<void>;
-    capabilities: number;
-    onDidChangeCapabilities: Event<any>;
-    onDidChangeFile: Event<any>;
-    watch(): IDisposable;
-    stat(): Promise<IStat>;
-    mkdir(): Promise<void>;
-    readdir(): Promise<[string, FileType][]>;
-    delete(): Promise<void>;
-    rename(): Promise<void>;
-}
-declare namespace CustomSchemas {
-    /**
-     * A schema that is used for models that exist in memory
-     * only and that have no correspondence on a server or such.
-     */
-    const extensionFile = "extension-file";
-}
-declare function getServiceOverride(): IEditorOverrideServices;
-/**
- * Register a custom file system provider for the given scheme. This allows us to override
- * the default file system provider for a given scheme.
- */
-declare function registerCustomProvider(scheme: string, provider: IFileSystemProvider): void;
-declare function registerExtensionFile(extensionLocation: URI, filePath: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
-/**
- * Can be used to create a file before the fileService is initialized
- */
-declare function initFile(file: URI, content: Uint8Array | string, options?: Partial<IFileWriteOptions>): Promise<void>;
-/**
- * Can be used to replace memory providers by indexeddb providers before the fileService is initialized
- */
-declare function createIndexedDBProviders(): Promise<IndexedDBFileSystemProvider>;
-/**
- * Can be used to replace the default filesystem provider by the HTMLFileSystemProvider before the fileService is initialized
- * Should be called "after" createIndexedDBProviders if used
- */
-declare function registerHTMLFileSystemProvider(): void;
-/**
- * Register a file system overlay
- *
- * By default, a memory filesystem is used to read and write file
- *
- * This method allows to register another fileSystemProvider in front OR behind the default memory one.
- *
- * The default one is registered as priority: 0, so:
- * - any provider registered with a positive priority will be in front of the default one
- * - any provider registered with a negative priority will be behind the default one
- */
-declare function registerFileSystemOverlay(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
-
-export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };

package/vscode/src/vs/base/browser/indexedDB.d.ts

@@ -1,17 +0,0 @@
-declare class IndexedDB {
-    private readonly name;
-    static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
-    private static openDatabase;
-    private static doOpenDatabase;
-    private static deleteDatabase;
-    private database;
-    private readonly pendingTransactions;
-    constructor(database: IDBDatabase, name: string);
-    hasPendingTransactions(): boolean;
-    close(): void;
-    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>[]): Promise<T[]>;
-    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
-    getKeyValues<V>(store: string, isValid: (value: unknown) => value is V): Promise<Map<string, V>>;
-}
-
-export { IndexedDB };