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

package/vscode/src/vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService.js

@@ -1,11 +1,13 @@
-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 { WORKSPACE_FILTER, hasWorkspaceFileExtension, WORKSPACE_EXTENSION, isSavedWorkspace, isUntitledWorkspace, toWorkspaceIdentifier, isWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { WORKSPACE_FILTER, hasWorkspaceFileExtension, WORKSPACE_EXTENSION, isSavedWorkspace, WorkbenchState, isUntitledWorkspace, toWorkspaceIdentifier, isWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { JSONEditingErrorCode } from '@codingame/monaco-vscode-d987325e-3e05-53aa-b9ff-6f97476f64db-common/vscode/vs/workbench/services/configuration/common/jsonEditing';
 import { IJSONEditingService } from 'vscode/vscode/vs/workbench/services/configuration/common/jsonEditing.service';
-import { rewriteWorkspaceFileForNewLocation } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';
+import { rewriteWorkspaceFileForNewLocation } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/workspaces/common/workspaces';
 import { IWorkspacesService } from 'vscode/vscode/vs/platform/workspaces/common/workspaces.service';
-import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { ConfigurationScope, Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { distinct } from 'vscode/vscode/vs/base/common/arrays';
@@ -19,13 +21,14 @@ import { mnemonicButtonLabel } from 'vscode/vscode/vs/base/common/labels';
 import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles.service';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { SaveReason } from 'vscode/vscode/vs/workbench/common/editor';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust.service';
-import { IWorkbenchConfigurationService } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration.service';
+import { IWorkbenchConfigurationService } from '@codingame/monaco-vscode-422642f2-7e3a-5c1c-9e1e-1d3ef1817346-common/vscode/vs/workbench/services/configuration/common/configuration.service';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService extends Disposable {
     constructor(jsonEditingService, contextService, configurationService, notificationService, commandService, fileService, textFileService, workspacesService, environmentService, fileDialogService, dialogService, hostService, uriIdentityService, workspaceTrustManagementService, userDataProfilesService, userDataProfileService) {
@@ -53,8 +56,8 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
             availableFileSystems.unshift(Schemas.vscodeRemote);
         }
         let workspacePath = await this.fileDialogService.showSaveDialog({
-            saveLabel: mnemonicButtonLabel(( localize(3681, "Save"))),
-            title: ( localize(3682, "Save Workspace")),
+            saveLabel: mnemonicButtonLabel(( localize(12115, "Save"))),
+            title: ( localize(12116, "Save Workspace")),
             filters: WORKSPACE_FILTER,
             defaultUri: joinPath(await this.fileDialogService.defaultWorkspacePath(), this.getNewWorkspaceName()),
             availableFileSystems
@@ -82,13 +85,13 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         const folders = this.contextService.getWorkspace().folders;
         let foldersToDelete = [];
         if (typeof deleteCount === 'number') {
-            foldersToDelete = ( (folders.slice(index, index + deleteCount).map(folder => folder.uri)));
+            foldersToDelete = ( folders.slice(index, index + deleteCount).map(folder => folder.uri));
         }
         let foldersToAdd = [];
         if (Array.isArray(foldersToAddCandidates)) {
-            foldersToAdd = ( (foldersToAddCandidates.map(
+            foldersToAdd = ( foldersToAddCandidates.map(
                 folderToAdd => ({ uri: removeTrailingPathSeparator(folderToAdd.uri), name: folderToAdd.name })
-            )));
+            ));
         }
         const wantsToDelete = foldersToDelete.length > 0;
         const wantsToAdd = foldersToAdd.length > 0;
@@ -105,7 +108,7 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
             if (this.includesSingleFolderWorkspace(foldersToDelete)) {
                 return this.createAndEnterWorkspace(foldersToAdd);
             }
-            if (this.contextService.getWorkbenchState() !== 3 ) {
+            if (this.contextService.getWorkbenchState() !== WorkbenchState.WORKSPACE) {
                 return this.doAddFolders(foldersToAdd, index, donotNotifyError);
             }
             return this.doUpdateFolders(foldersToAdd, foldersToDelete, index, donotNotifyError);
@@ -123,18 +126,18 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         }
     }
     addFolders(foldersToAddCandidates, donotNotifyError = false) {
-        const foldersToAdd = ( (foldersToAddCandidates.map(
+        const foldersToAdd = ( foldersToAddCandidates.map(
             folderToAdd => ({ uri: removeTrailingPathSeparator(folderToAdd.uri), name: folderToAdd.name })
-        )));
+        ));
         return this.doAddFolders(foldersToAdd, undefined, donotNotifyError);
     }
     async doAddFolders(foldersToAdd, index, donotNotifyError = false) {
         const state = this.contextService.getWorkbenchState();
-        if (state !== 3 ) {
-            let newWorkspaceFolders = ( (this.contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri }))));
+        if (state !== WorkbenchState.WORKSPACE) {
+            let newWorkspaceFolders = ( this.contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri })));
             newWorkspaceFolders.splice(typeof index === 'number' ? index : newWorkspaceFolders.length, 0, ...foldersToAdd);
             newWorkspaceFolders = distinct(newWorkspaceFolders, folder => this.uriIdentityService.extUri.getComparisonKey(folder.uri));
-            if (state === 1  && newWorkspaceFolders.length === 0 || state === 2  && newWorkspaceFolders.length === 1) {
+            if (state === WorkbenchState.EMPTY && newWorkspaceFolders.length === 0 || state === WorkbenchState.FOLDER && newWorkspaceFolders.length === 1) {
                 return;
             }
             return this.createAndEnterWorkspace(newWorkspaceFolders);
@@ -164,13 +167,11 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         }
     }
     includesSingleFolderWorkspace(folders) {
-        if (this.contextService.getWorkbenchState() === 2 ) {
+        if (this.contextService.getWorkbenchState() === WorkbenchState.FOLDER) {
             const workspaceFolder = this.contextService.getWorkspace().folders[0];
-            return (
-                 (folders.some(
-                    folder => this.uriIdentityService.extUri.isEqual(folder, workspaceFolder.uri)
-                ))
-            );
+            return ( folders.some(
+                folder => this.uriIdentityService.extUri.isEqual(folder, workspaceFolder.uri)
+            ));
         }
         return false;
     }
@@ -225,7 +226,7 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         }
         const isFromUntitledWorkspace = isUntitledWorkspace(configPathURI, this.environmentService);
         const raw = await this.fileService.readFile(configPathURI);
-        const newRawWorkspaceContents = rewriteWorkspaceFileForNewLocation(( (raw.value.toString())), configPathURI, isFromUntitledWorkspace, targetConfigPathURI, this.uriIdentityService.extUri);
+        const newRawWorkspaceContents = rewriteWorkspaceFileForNewLocation(( raw.value.toString()), configPathURI, isFromUntitledWorkspace, targetConfigPathURI, this.uriIdentityService.extUri);
         await this.textFileService.create([{ resource: targetConfigPathURI, value: newRawWorkspaceContents, options: { overwrite: true } }]);
         await this.trustWorkspaceConfiguration(targetConfigPathURI);
     }
@@ -233,7 +234,7 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         const configPathURI = workspace.configPath;
         const existingModel = this.textFileService.files.get(configPathURI);
         if (existingModel) {
-            await existingModel.save({ force: true, reason: 1  });
+            await existingModel.save({ force: true, reason: SaveReason.EXPLICIT });
             return;
         }
         const workspaceFileExists = await this.fileService.exists(configPathURI);
@@ -246,7 +247,7 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
     }
     handleWorkspaceConfigurationEditingError(error) {
         switch (error.code) {
-            case 0 :
+            case JSONEditingErrorCode.ERROR_INVALID_FILE:
                 this.onInvalidWorkspaceConfigurationFileError();
                 break;
             default:
@@ -255,38 +256,38 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
     }
     onInvalidWorkspaceConfigurationFileError() {
         const message = ( localize(
-            3683,
+            12117,
             "Unable to write into workspace configuration file. Please open the file to correct errors/warnings in it and try again."
         ));
         this.askToOpenWorkspaceConfigurationFile(message);
     }
     askToOpenWorkspaceConfigurationFile(message) {
-        this.notificationService.prompt(Severity$1.Error, message, [{
-                label: ( localize(3684, "Open Workspace Configuration")),
+        this.notificationService.prompt(Severity.Error, message, [{
+                label: ( localize(12118, "Open Workspace Configuration")),
                 run: () => this.commandService.executeCommand('workbench.action.openWorkspaceConfigFile')
             }]);
     }
     async doEnterWorkspace(workspaceUri) {
         if (!!this.environmentService.extensionTestsLocationURI) {
-            throw ( (new Error('Entering a new workspace is not possible in tests.')));
+            throw ( new Error('Entering a new workspace is not possible in tests.'));
         }
         const workspace = await this.workspacesService.getWorkspaceIdentifier(workspaceUri);
-        if (this.contextService.getWorkbenchState() === 2 ) {
+        if (this.contextService.getWorkbenchState() === WorkbenchState.FOLDER) {
             await this.migrateWorkspaceSettings(workspace);
         }
         await this.configurationService.initialize(workspace);
         return this.workspacesService.enterWorkspace(workspaceUri);
     }
     migrateWorkspaceSettings(toWorkspace) {
-        return this.doCopyWorkspaceSettings(toWorkspace, setting => setting.scope === 3 );
+        return this.doCopyWorkspaceSettings(toWorkspace, setting => setting.scope === ConfigurationScope.WINDOW);
     }
     copyWorkspaceSettings(toWorkspace) {
         return this.doCopyWorkspaceSettings(toWorkspace);
     }
     doCopyWorkspaceSettings(toWorkspace, filter) {
-        const configurationProperties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
+        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
         const targetWorkspaceConfiguration = {};
-        for (const key of ( (this.configurationService.keys())).workspace) {
+        for (const key of ( this.configurationService.keys()).workspace) {
             if (configurationProperties[key]) {
                 if (filter && !filter(configurationProperties[key])) {
                     continue;
@@ -297,7 +298,7 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         return this.jsonEditingService.write(toWorkspace.configPath, [{ path: ['settings'], value: targetWorkspaceConfiguration }], true);
     }
     async trustWorkspaceConfiguration(configPathURI) {
-        if (this.contextService.getWorkbenchState() !== 1  && this.workspaceTrustManagementService.isWorkspaceTrusted()) {
+        if (this.contextService.getWorkbenchState() !== WorkbenchState.EMPTY && this.workspaceTrustManagementService.isWorkspaceTrusted()) {
             await this.workspaceTrustManagementService.setUrisTrust([configPathURI], true);
         }
     }
@@ -309,23 +310,23 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService exte
         return undefined;
     }
 };
-AbstractWorkspaceEditingService = ( (__decorate([
-    ( (__param(0, IJSONEditingService))),
-    ( (__param(1, IWorkspaceContextService))),
-    ( (__param(2, IWorkbenchConfigurationService))),
-    ( (__param(3, INotificationService))),
-    ( (__param(4, ICommandService))),
-    ( (__param(5, IFileService))),
-    ( (__param(6, ITextFileService))),
-    ( (__param(7, IWorkspacesService))),
-    ( (__param(8, IWorkbenchEnvironmentService))),
-    ( (__param(9, IFileDialogService))),
-    ( (__param(10, IDialogService))),
-    ( (__param(11, IHostService))),
-    ( (__param(12, IUriIdentityService))),
-    ( (__param(13, IWorkspaceTrustManagementService))),
-    ( (__param(14, IUserDataProfilesService))),
-    ( (__param(15, IUserDataProfileService)))
-], AbstractWorkspaceEditingService)));
+AbstractWorkspaceEditingService = ( __decorate([
+    ( __param(0, IJSONEditingService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IWorkbenchConfigurationService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, IWorkspacesService)),
+    ( __param(8, IWorkbenchEnvironmentService)),
+    ( __param(9, IFileDialogService)),
+    ( __param(10, IDialogService)),
+    ( __param(11, IHostService)),
+    ( __param(12, IUriIdentityService)),
+    ( __param(13, IWorkspaceTrustManagementService)),
+    ( __param(14, IUserDataProfilesService)),
+    ( __param(15, IUserDataProfileService))
+], AbstractWorkspaceEditingService));
 
 export { AbstractWorkspaceEditingService };

package/vscode/src/vs/workbench/services/workspaces/browser/workspacesService.d.ts

@@ -0,0 +1,39 @@
+import { IWorkspaceFolderCreationData, IEnterWorkspaceResult, IRecentlyOpened, IRecent } from "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/workspaces/common/workspaces";
+import { IWorkspacesService } from "vscode/vscode/vs/platform/workspaces/common/workspaces.service";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceIdentifier } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceBackupInfo, IFolderBackupInfo } from "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/backup/common/backup";
+export declare class BrowserWorkspacesService extends Disposable implements IWorkspacesService {
+    private readonly storageService;
+    private readonly contextService;
+    private readonly logService;
+    private readonly fileService;
+    private readonly environmentService;
+    private readonly uriIdentityService;
+    static readonly RECENTLY_OPENED_KEY = "recently.opened";
+    readonly _serviceBrand: undefined;
+    private readonly _onRecentlyOpenedChange;
+    readonly onDidChangeRecentlyOpened: import("vscode/vscode/vs/base/common/event").Event<void>;
+    constructor(storageService: IStorageService, contextService: IWorkspaceContextService, logService: ILogService, fileService: IFileService, environmentService: IWorkbenchEnvironmentService, uriIdentityService: IUriIdentityService);
+    private registerListeners;
+    private onDidChangeWorkspaceFolders;
+    private addWorkspaceToRecentlyOpened;
+    getRecentlyOpened(): Promise<IRecentlyOpened>;
+    addRecentlyOpened(recents: IRecent[]): Promise<void>;
+    removeRecentlyOpened(paths: URI[]): Promise<void>;
+    private doRemoveRecentlyOpened;
+    private saveRecentlyOpened;
+    clearRecentlyOpened(): Promise<void>;
+    enterWorkspace(workspaceUri: URI): Promise<IEnterWorkspaceResult | undefined>;
+    createUntitledWorkspace(folders?: IWorkspaceFolderCreationData[], remoteAuthority?: string): Promise<IWorkspaceIdentifier>;
+    deleteUntitledWorkspace(workspace: IWorkspaceIdentifier): Promise<void>;
+    getWorkspaceIdentifier(workspaceUri: URI): Promise<IWorkspaceIdentifier>;
+    getDirtyWorkspaces(): Promise<Array<IWorkspaceBackupInfo | IFolderBackupInfo>>;
+}

package/vscode/src/vs/workbench/services/workspaces/browser/workspacesService.js

@@ -1,13 +1,17 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { restoreRecentlyOpened, isRecentFolder, isRecentWorkspace, isRecentFile, toStoreData, getStoredWorkspaceFolder } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { restoreRecentlyOpened, isRecentFolder, isRecentWorkspace, isRecentFile, toStoreData, getStoredWorkspaceFolder } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/workspaces/common/workspaces';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { isTemporaryWorkspace, WORKSPACE_EXTENSION } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { isTemporaryWorkspace, WorkbenchState, WORKSPACE_EXTENSION } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { getWorkspaceIdentifier } from 'vscode/vscode/vs/workbench/services/workspaces/browser/workspaces';
+import { FileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
@@ -33,7 +37,7 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         this.registerListeners();
     }
     registerListeners() {
-        this._register(this.storageService.onDidChangeValue(-1 , BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, this._register(( new DisposableStore())))(() => this._onRecentlyOpenedChange.fire()));
+        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, this._store)(() => this._onRecentlyOpenedChange.fire()));
         this._register(this.contextService.onDidChangeWorkspaceFolders(e => this.onDidChangeWorkspaceFolders(e)));
     }
     onDidChangeWorkspaceFolders(e) {
@@ -48,16 +52,16 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         const workspace = this.contextService.getWorkspace();
         const remoteAuthority = this.environmentService.remoteAuthority;
         switch (this.contextService.getWorkbenchState()) {
-            case 2 :
+            case WorkbenchState.FOLDER:
                 this.addRecentlyOpened([{ folderUri: workspace.folders[0].uri, remoteAuthority }]);
                 break;
-            case 3 :
+            case WorkbenchState.WORKSPACE:
                 this.addRecentlyOpened([{ workspace: { id: workspace.id, configPath: workspace.configuration }, remoteAuthority }]);
                 break;
         }
     }
     async getRecentlyOpened() {
-        const recentlyOpenedRaw = this.storageService.get(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, -1 );
+        const recentlyOpenedRaw = this.storageService.get(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, StorageScope.APPLICATION);
         if (recentlyOpenedRaw) {
             const recentlyOpened = restoreRecentlyOpened(JSON.parse(recentlyOpenedRaw), this.logService);
             recentlyOpened.workspaces = recentlyOpened.workspaces.filter(recent => {
@@ -105,10 +109,10 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         });
     }
     async saveRecentlyOpened(data) {
-        return this.storageService.store(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, JSON.stringify(toStoreData(data)), -1 , 0 );
+        return this.storageService.store(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, JSON.stringify(toStoreData(data)), StorageScope.APPLICATION, StorageTarget.USER);
     }
     async clearRecentlyOpened() {
-        this.storageService.remove(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, -1 );
+        this.storageService.remove(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, StorageScope.APPLICATION);
     }
     async enterWorkspace(workspaceUri) {
         return { workspace: await this.getWorkspaceIdentifier(workspaceUri) };
@@ -131,7 +135,7 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
             await this.fileService.del(workspace.configPath);
         }
         catch (error) {
-            if (error.fileOperationResult !== 1 ) {
+            if (error.fileOperationResult !== FileOperationResult.FILE_NOT_FOUND) {
                 throw error;
             }
         }

package/configuration.js

@@ -1,138 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { ITextResourceConfigurationService, ITextResourcePropertiesService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
-import { TextResourceConfigurationService } from './vscode/src/vs/editor/common/services/textResourceConfigurationService.js';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-export { ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { IPolicyService } from 'vscode/vscode/vs/platform/policy/common/policy.service';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { IWorkspacesService } from 'vscode/vscode/vs/platform/workspaces/common/workspaces.service';
-import './vscode/src/vs/workbench/api/common/configurationExtensionPoint.js';
-import './vscode/src/vs/workbench/contrib/workspaces/browser/workspaces.contribution.js';
-import { WorkspaceService } from './vscode/src/vs/workbench/services/configuration/browser/configurationService.js';
-import { ConfigurationCache } from './vscode/src/vs/workbench/services/configuration/common/configurationCache.js';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
-import { TextResourcePropertiesService } from './vscode/src/vs/workbench/services/textresourceProperties/common/textResourcePropertiesService.js';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
-import { AbstractWorkspaceEditingService } from './vscode/src/vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService.js';
-import { BrowserWorkspacesService } from './vscode/src/vs/workbench/services/workspaces/browser/workspacesService.js';
-import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service';
-import { ConfigurationResolverService } from './vscode/src/vs/workbench/services/configurationResolver/browser/configurationResolverService.js';
-import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
-import getServiceOverride$1, { initFile } from '@codingame/monaco-vscode-files-service-override';
-import { registerServiceInitializePreParticipant } from 'vscode/lifecycle';
-import { getService, withReadyServices } from 'vscode/services';
-import { unsupported, memoizedConstructor } from './tools.js';
-import { getWorkspaceIdentifier } from 'vscode/workbench';
-
-const defaultUserConfigurationFile = ( URI.from({
-    scheme: Schemas.vscodeUserData,
-    path: '/User/settings.json'
-}));
-async function initUserConfiguration(configurationJson, options, file = defaultUserConfigurationFile) {
-    await initFile(file, configurationJson, options);
-}
-async function updateUserConfiguration(configurationJson) {
-    const userDataProfilesService = await getService(IUserDataProfilesService);
-    const fileService = await getService(IFileService);
-    await fileService.writeFile(userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString(configurationJson));
-}
-async function getUserConfiguration() {
-    const userDataProfilesService = await getService(IUserDataProfilesService);
-    const fileService = await getService(IFileService);
-    return ( (await fileService.readFile(userDataProfilesService.defaultProfile.settingsResource)).value.toString());
-}
-function onUserConfigurationChange(callback) {
-    return withReadyServices((accessor) => {
-        const userDataProfilesService = accessor.get(IUserDataProfilesService);
-        return accessor.get(IFileService).onDidFilesChange((e) => {
-            if (e.affects(userDataProfilesService.defaultProfile.settingsResource)) {
-                callback();
-            }
-        });
-    });
-}
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
-let InjectedConfigurationService = class InjectedConfigurationService extends WorkspaceService {
-    constructor(workbenchEnvironmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService) {
-        const configurationCache = new ConfigurationCache([Schemas.file, Schemas.vscodeUserData, Schemas.tmp], workbenchEnvironmentService, fileService);
-        super({ configurationCache }, workbenchEnvironmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService);
-    }
-};
-InjectedConfigurationService = __decorate([
-    ( __param(0, IWorkbenchEnvironmentService)),
-    ( __param(1, IUserDataProfileService)),
-    ( __param(2, IUserDataProfilesService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IRemoteAgentService)),
-    ( __param(5, IUriIdentityService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IPolicyService))
-], InjectedConfigurationService);
-class MonacoWorkspaceEditingService extends AbstractWorkspaceEditingService {
-    constructor() {
-        super(...arguments);
-        this.enterWorkspace = unsupported;
-    }
-}
-let _defaultWorkspace;
-registerServiceInitializePreParticipant(async (accessor) => {
-    const workspaceService = accessor.get(IWorkspaceContextService);
-    workspaceService.acquireInstantiationService(accessor.get(IInstantiationService));
-    const workspace = _defaultWorkspace ?? getWorkspaceIdentifier();
-    if (URI.isUri(workspace)) {
-        const configPath = workspace.with({ path: '/workspace.code-workspace' });
-        try {
-            const fileService = accessor.get(IFileService);
-            await fileService.createFolder(workspace);
-            await fileService.writeFile(configPath, VSBuffer.fromString(JSON.stringify({
-                folders: [
-                    {
-                        path: workspace.path
-                    }
-                ]
-            })));
-        }
-        catch (err) {
-        }
-        await workspaceService.initialize({
-            id: generateUuid(),
-            configPath
-        });
-    }
-    else {
-        await workspaceService.initialize(workspace);
-    }
-});
-const MemoizedInjectedConfigurationService = memoizedConstructor(InjectedConfigurationService);
-async function reinitializeWorkspace(workspace) {
-    const workspaceService = (await getService(IWorkspaceContextService));
-    await workspaceService.initialize(workspace);
-}
-function getServiceOverride(defaultWorkspace) {
-    _defaultWorkspace = defaultWorkspace;
-    return {
-        ...getServiceOverride$1(),
-        [( IConfigurationService.toString())]: new SyncDescriptor(MemoizedInjectedConfigurationService, [], true),
-        [( IWorkspaceContextService.toString())]: new SyncDescriptor(MemoizedInjectedConfigurationService, [], true),
-        [( ITextResourceConfigurationService.toString())]: new SyncDescriptor(TextResourceConfigurationService, [], true),
-        [( IWorkspaceEditingService.toString())]: new SyncDescriptor(MonacoWorkspaceEditingService, [], true),
-        [( IWorkspacesService.toString())]: new SyncDescriptor(BrowserWorkspacesService, [], true),
-        [( ITextResourcePropertiesService.toString())]: new SyncDescriptor(TextResourcePropertiesService, [], true),
-        [( IConfigurationResolverService.toString())]: new SyncDescriptor(ConfigurationResolverService, [], true)
-    };
-}
-
-export { configurationRegistry, getServiceOverride as default, defaultUserConfigurationFile, getUserConfiguration, initUserConfiguration, onUserConfigurationChange, reinitializeWorkspace, updateUserConfiguration };

package/tools.js

@@ -1,44 +0,0 @@
-function unsupported() {
-    throw new Error('unsupported');
-}
-function memoized(fct) {
-    let v = null;
-    return (...args) => {
-        if (v == null) {
-            v = fct(...args);
-        }
-        return v;
-    };
-}
-function memoizedConstructor(ctor) {
-    return new Proxy(ctor, {
-        construct: memoized((target, args) => {
-            return Reflect.construct(ctor, args);
-        })
-    });
-}
-async function sleep(duration) {
-    await new Promise((resolve) => setTimeout(resolve, duration));
-}
-function throttle(fct, merge, delay) {
-    let lastPromise = Promise.resolve();
-    let toConsume = null;
-    return async (param) => {
-        if (toConsume == null) {
-            toConsume = param;
-            lastPromise = lastPromise
-                .then(async () => await sleep(delay))
-                .then(async () => {
-                const _toConsume = toConsume;
-                toConsume = null;
-                await fct(_toConsume);
-            });
-        }
-        else {
-            toConsume = merge(toConsume, param);
-        }
-        await lastPromise;
-    };
-}
-
-export { memoized, memoizedConstructor, sleep, throttle, unsupported };