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

package/vscode/src/vs/workbench/services/configuration/common/configurationEditing.js

@@ -1,16 +1,19 @@
-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 { parse } from 'vscode/vscode/vs/base/common/json';
-import { setProperty } from 'vscode/vscode/vs/base/common/jsonEdit';
+import { setProperty } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/base/common/jsonEdit';
 import { Queue } from 'vscode/vscode/vs/base/common/async';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles.service';
-import { TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY, TASKS_DEFAULT, FOLDER_SCOPES, USER_STANDALONE_CONFIGURATIONS, WORKSPACE_STANDALONE_CONFIGURATIONS, FOLDER_SETTINGS_PATH } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
-import { IWorkbenchConfigurationService } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration.service';
+import { TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY, TASKS_DEFAULT, FOLDER_SCOPES, USER_STANDALONE_CONFIGURATIONS, WORKSPACE_STANDALONE_CONFIGURATIONS, FOLDER_SETTINGS_PATH } from '@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration';
+import { IWorkbenchConfigurationService } from '@codingame/monaco-vscode-422642f2-7e3a-5c1c-9e1e-1d3ef1817346-common/vscode/vs/workbench/services/configuration/common/configuration.service';
+import { FileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { Extensions, OVERRIDE_PROPERTY_REGEX, keyFromOverrideIdentifiers } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Extensions, OVERRIDE_PROPERTY_REGEX, ConfigurationScope, keyFromOverrideIdentifiers } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import 'vscode/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
@@ -22,14 +25,38 @@ import { Selection } from 'vscode/vscode/vs/editor/common/core/selection';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
+var ConfigurationEditingErrorCode;
+(function (ConfigurationEditingErrorCode) {
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_UNKNOWN_KEY"] = 0] = "ERROR_UNKNOWN_KEY";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION"] = 1] = "ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_WORKSPACE_CONFIGURATION_MACHINE"] = 2] = "ERROR_INVALID_WORKSPACE_CONFIGURATION_MACHINE";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_FOLDER_CONFIGURATION"] = 3] = "ERROR_INVALID_FOLDER_CONFIGURATION";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_USER_TARGET"] = 4] = "ERROR_INVALID_USER_TARGET";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_WORKSPACE_TARGET"] = 5] = "ERROR_INVALID_WORKSPACE_TARGET";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_FOLDER_TARGET"] = 6] = "ERROR_INVALID_FOLDER_TARGET";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_RESOURCE_LANGUAGE_CONFIGURATION"] = 7] = "ERROR_INVALID_RESOURCE_LANGUAGE_CONFIGURATION";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_NO_WORKSPACE_OPENED"] = 8] = "ERROR_NO_WORKSPACE_OPENED";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_CONFIGURATION_FILE_DIRTY"] = 9] = "ERROR_CONFIGURATION_FILE_DIRTY";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_CONFIGURATION_FILE_MODIFIED_SINCE"] = 10] = "ERROR_CONFIGURATION_FILE_MODIFIED_SINCE";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INVALID_CONFIGURATION"] = 11] = "ERROR_INVALID_CONFIGURATION";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_POLICY_CONFIGURATION"] = 12] = "ERROR_POLICY_CONFIGURATION";
+    ConfigurationEditingErrorCode[ConfigurationEditingErrorCode["ERROR_INTERNAL"] = 13] = "ERROR_INTERNAL";
+})(ConfigurationEditingErrorCode || (ConfigurationEditingErrorCode = {}));
 class ConfigurationEditingError extends ErrorNoTelemetry {
     constructor(message, code) {
         super(message);
         this.code = code;
     }
 }
+var EditableConfigurationTarget;
+(function (EditableConfigurationTarget) {
+    EditableConfigurationTarget[EditableConfigurationTarget["USER_LOCAL"] = 1] = "USER_LOCAL";
+    EditableConfigurationTarget[EditableConfigurationTarget["USER_REMOTE"] = 2] = "USER_REMOTE";
+    EditableConfigurationTarget[EditableConfigurationTarget["WORKSPACE"] = 3] = "WORKSPACE";
+    EditableConfigurationTarget[EditableConfigurationTarget["WORKSPACE_FOLDER"] = 4] = "WORKSPACE_FOLDER";
+})(EditableConfigurationTarget || (EditableConfigurationTarget = {}));
 let ConfigurationEditing = class ConfigurationEditing {
     constructor(remoteSettingsResource, configurationService, contextService, userDataProfileService, userDataProfilesService, fileService, textModelResolverService, textFileService, notificationService, preferencesService, editorService, uriIdentityService) {
         this.remoteSettingsResource = remoteSettingsResource;
@@ -44,7 +71,7 @@ let ConfigurationEditing = class ConfigurationEditing {
         this.preferencesService = preferencesService;
         this.editorService = editorService;
         this.uriIdentityService = uriIdentityService;
-        this.queue = ( (new Queue()));
+        this.queue = ( new Queue());
     }
     async writeConfiguration(target, value, options = {}) {
         const operation = this.getConfigurationEditOperation(target, value, options.scopes || {});
@@ -74,7 +101,7 @@ let ConfigurationEditing = class ConfigurationEditing {
     }
     async updateConfiguration(operation, model, formattingOptions, options) {
         if (this.hasParseErrors(model.getValue(), operation)) {
-            throw this.toConfigurationEditingError(11 , operation.target, operation);
+            throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_CONFIGURATION, operation.target, operation);
         }
         if (this.textFileService.isDirty(model.uri) && options.handleDirtyFile) {
             switch (options.handleDirtyFile) {
@@ -96,35 +123,35 @@ let ConfigurationEditing = class ConfigurationEditing {
             await this.textFileService.save(model.uri, { ignoreErrorHandler: true });
         }
         catch (error) {
-            if (error.fileOperationResult === 3 ) {
-                throw this.toConfigurationEditingError(10 , operation.target, operation);
+            if (error.fileOperationResult === FileOperationResult.FILE_MODIFIED_SINCE) {
+                throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_MODIFIED_SINCE, operation.target, operation);
             }
-            throw ( (new ConfigurationEditingError(localize(
-                8951,
+            throw ( new ConfigurationEditingError(( localize(
+                11266,
                 "Error while writing to {0}. {1}",
                 this.stringifyTarget(operation.target),
                 error.message
-            ), 13 )));
+            )), ConfigurationEditingErrorCode.ERROR_INTERNAL));
         }
     }
     applyEditsToBuffer(edit, model) {
         const startPosition = model.getPositionAt(edit.offset);
         const endPosition = model.getPositionAt(edit.offset + edit.length);
-        const range = ( (new Range(
+        const range = ( new Range(
             startPosition.lineNumber,
             startPosition.column,
             endPosition.lineNumber,
             endPosition.column
-        )));
+        ));
         const currentText = model.getValueInRange(range);
         if (edit.content !== currentText) {
             const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
-            model.pushEditOperations([( (new Selection(
+            model.pushEditOperations([( new Selection(
                 startPosition.lineNumber,
                 startPosition.column,
                 startPosition.lineNumber,
                 startPosition.column
-            )))], [editOperation], () => []);
+            ))], [editOperation], () => []);
             return true;
         }
         return false;
@@ -147,42 +174,42 @@ let ConfigurationEditing = class ConfigurationEditing {
     }
     async onError(error, operation, scopes) {
         switch (error.code) {
-            case 11 :
+            case ConfigurationEditingErrorCode.ERROR_INVALID_CONFIGURATION:
                 this.onInvalidConfigurationError(error, operation);
                 break;
-            case 9 :
+            case ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_DIRTY:
                 this.onConfigurationFileDirtyError(error, operation, scopes);
                 break;
-            case 10 :
+            case ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_MODIFIED_SINCE:
                 return this.doWriteConfiguration(operation, { scopes, handleDirtyFile: 'revert' });
             default:
                 this.notificationService.error(error.message);
         }
     }
     onInvalidConfigurationError(error, operation) {
-        const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? ( localize(8952, "Open Tasks Configuration"))
-            : operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? ( localize(8953, "Open Launch Configuration"))
+        const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? ( localize(11267, "Open Tasks Configuration"))
+            : operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? ( localize(11268, "Open Launch Configuration"))
                 : null;
         if (openStandAloneConfigurationActionLabel) {
-            this.notificationService.prompt(Severity$1.Error, error.message, [{
+            this.notificationService.prompt(Severity.Error, error.message, [{
                     label: openStandAloneConfigurationActionLabel,
                     run: () => this.openFile(operation.resource)
                 }]);
         }
         else {
-            this.notificationService.prompt(Severity$1.Error, error.message, [{
-                    label: ( localize(8954, "Open Settings")),
+            this.notificationService.prompt(Severity.Error, error.message, [{
+                    label: ( localize(11269, "Open Settings")),
                     run: () => this.openSettings(operation)
                 }]);
         }
     }
     onConfigurationFileDirtyError(error, operation, scopes) {
-        const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? ( localize(8952, "Open Tasks Configuration"))
-            : operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? ( localize(8953, "Open Launch Configuration"))
+        const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? ( localize(11267, "Open Tasks Configuration"))
+            : operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? ( localize(11268, "Open Launch Configuration"))
                 : null;
         if (openStandAloneConfigurationActionLabel) {
-            this.notificationService.prompt(Severity$1.Error, error.message, [{
-                    label: ( localize(8955, "Save and Retry")),
+            this.notificationService.prompt(Severity.Error, error.message, [{
+                    label: ( localize(11270, "Save and Retry")),
                     run: () => {
                         const key = operation.key ? `${operation.workspaceStandAloneConfigurationKey}.${operation.key}` : operation.workspaceStandAloneConfigurationKey;
                         this.writeConfiguration(operation.target, { key, value: operation.value }, { handleDirtyFile: 'save', scopes });
@@ -194,12 +221,12 @@ let ConfigurationEditing = class ConfigurationEditing {
                 }]);
         }
         else {
-            this.notificationService.prompt(Severity$1.Error, error.message, [{
-                    label: ( localize(8955, "Save and Retry")),
+            this.notificationService.prompt(Severity.Error, error.message, [{
+                    label: ( localize(11270, "Save and Retry")),
                     run: () => this.writeConfiguration(operation.target, { key: operation.key, value: operation.value }, { handleDirtyFile: 'save', scopes })
                 },
                 {
-                    label: ( localize(8954, "Open Settings")),
+                    label: ( localize(11269, "Open Settings")),
                     run: () => this.openSettings(operation)
                 }]);
         }
@@ -207,16 +234,16 @@ let ConfigurationEditing = class ConfigurationEditing {
     openSettings(operation) {
         const options = { jsonEditor: true };
         switch (operation.target) {
-            case 1 :
+            case EditableConfigurationTarget.USER_LOCAL:
                 this.preferencesService.openUserSettings(options);
                 break;
-            case 2 :
+            case EditableConfigurationTarget.USER_REMOTE:
                 this.preferencesService.openRemoteSettings(options);
                 break;
-            case 3 :
+            case EditableConfigurationTarget.WORKSPACE:
                 this.preferencesService.openWorkspaceSettings(options);
                 break;
-            case 4 :
+            case EditableConfigurationTarget.WORKSPACE_FOLDER:
                 if (operation.resource) {
                     const workspaceFolder = this.contextService.getWorkspaceFolder(operation.resource);
                     if (workspaceFolder) {
@@ -231,92 +258,90 @@ let ConfigurationEditing = class ConfigurationEditing {
     }
     toConfigurationEditingError(code, target, operation) {
         const message = this.toErrorMessage(code, target, operation);
-        return (
-             (new ConfigurationEditingError(message, code))
-        );
+        return ( new ConfigurationEditingError(message, code));
     }
     toErrorMessage(error, target, operation) {
         switch (error) {
-            case 12 : return ( localize(
-                8956,
+            case ConfigurationEditingErrorCode.ERROR_POLICY_CONFIGURATION: return localize(
+                11271,
                 "Unable to write {0} because it is configured in system policy.",
                 operation.key
-            ));
-            case 0 : return ( localize(
-                8957,
+            );
+            case ConfigurationEditingErrorCode.ERROR_UNKNOWN_KEY: return localize(
+                11272,
                 "Unable to write to {0} because {1} is not a registered configuration.",
                 this.stringifyTarget(target),
                 operation.key
-            ));
-            case 1 : return ( localize(
-                8958,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION: return localize(
+                11273,
                 "Unable to write {0} to Workspace Settings. This setting can be written only into User settings.",
                 operation.key
-            ));
-            case 2 : return ( localize(
-                8959,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_MACHINE: return localize(
+                11274,
                 "Unable to write {0} to Workspace Settings. This setting can be written only into User settings.",
                 operation.key
-            ));
-            case 3 : return ( localize(
-                8960,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_CONFIGURATION: return localize(
+                11275,
                 "Unable to write to Folder Settings because {0} does not support the folder resource scope.",
                 operation.key
-            ));
-            case 4 : return ( localize(
-                8961,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_USER_TARGET: return localize(
+                11276,
                 "Unable to write to User Settings because {0} does not support for global scope.",
                 operation.key
-            ));
-            case 5 : return ( localize(
-                8962,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_TARGET: return localize(
+                11277,
                 "Unable to write to Workspace Settings because {0} does not support for workspace scope in a multi folder workspace.",
                 operation.key
-            ));
-            case 6 : return ( localize(
-                8963,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_TARGET: return localize(
+                11278,
                 "Unable to write to Folder Settings because no resource is provided."
-            ));
-            case 7 : return ( localize(
-                8964,
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_RESOURCE_LANGUAGE_CONFIGURATION: return localize(
+                11279,
                 "Unable to write to Language Settings because {0} is not a resource language setting.",
                 operation.key
-            ));
-            case 8 : return ( localize(
-                8965,
+            );
+            case ConfigurationEditingErrorCode.ERROR_NO_WORKSPACE_OPENED: return localize(
+                11280,
                 "Unable to write to {0} because no workspace is opened. Please open a workspace first and try again.",
                 this.stringifyTarget(target)
-            ));
-            case 11 : {
+            );
+            case ConfigurationEditingErrorCode.ERROR_INVALID_CONFIGURATION: {
                 if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
-                    return ( localize(
-                        8966,
+                    return localize(
+                        11281,
                         "Unable to write into the tasks configuration file. Please open it to correct errors/warnings in it and try again."
-                    ));
+                    );
                 }
                 if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
-                    return ( localize(
-                        8967,
+                    return localize(
+                        11282,
                         "Unable to write into the launch configuration file. Please open it to correct errors/warnings in it and try again."
-                    ));
+                    );
                 }
                 switch (target) {
-                    case 1 :
-                        return ( localize(
-                            8968,
+                    case EditableConfigurationTarget.USER_LOCAL:
+                        return localize(
+                            11283,
                             "Unable to write into user settings. Please open the user settings to correct errors/warnings in it and try again."
-                        ));
-                    case 2 :
-                        return ( localize(
-                            8969,
+                        );
+                    case EditableConfigurationTarget.USER_REMOTE:
+                        return localize(
+                            11284,
                             "Unable to write into remote user settings. Please open the remote user settings to correct errors/warnings in it and try again."
-                        ));
-                    case 3 :
-                        return ( localize(
-                            8970,
+                        );
+                    case EditableConfigurationTarget.WORKSPACE:
+                        return localize(
+                            11285,
                             "Unable to write into workspace settings. Please open the workspace settings to correct errors/warnings in the file and try again."
-                        ));
-                    case 4 : {
+                        );
+                    case EditableConfigurationTarget.WORKSPACE_FOLDER: {
                         let workspaceFolderName = '<<unknown>>';
                         if (operation.resource) {
                             const folder = this.contextService.getWorkspaceFolder(operation.resource);
@@ -324,46 +349,46 @@ let ConfigurationEditing = class ConfigurationEditing {
                                 workspaceFolderName = folder.name;
                             }
                         }
-                        return ( localize(
-                            8971,
+                        return localize(
+                            11286,
                             "Unable to write into folder settings. Please open the '{0}' folder settings to correct errors/warnings in it and try again.",
                             workspaceFolderName
-                        ));
+                        );
                     }
                     default:
                         return '';
                 }
             }
-            case 9 : {
+            case ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_DIRTY: {
                 if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
-                    return ( localize(
-                        8972,
+                    return localize(
+                        11287,
                         "Unable to write into tasks configuration file because the file has unsaved changes. Please save it first and then try again."
-                    ));
+                    );
                 }
                 if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
-                    return ( localize(
-                        8973,
+                    return localize(
+                        11288,
                         "Unable to write into launch configuration file because the file has unsaved changes. Please save it first and then try again."
-                    ));
+                    );
                 }
                 switch (target) {
-                    case 1 :
-                        return ( localize(
-                            8974,
+                    case EditableConfigurationTarget.USER_LOCAL:
+                        return localize(
+                            11289,
                             "Unable to write into user settings because the file has unsaved changes. Please save the user settings file first and then try again."
-                        ));
-                    case 2 :
-                        return ( localize(
-                            8975,
+                        );
+                    case EditableConfigurationTarget.USER_REMOTE:
+                        return localize(
+                            11290,
                             "Unable to write into remote user settings because the file has unsaved changes. Please save the remote user settings file first and then try again."
-                        ));
-                    case 3 :
-                        return ( localize(
-                            8976,
+                        );
+                    case EditableConfigurationTarget.WORKSPACE:
+                        return localize(
+                            11291,
                             "Unable to write into workspace settings because the file has unsaved changes. Please save the workspace settings file first and then try again."
-                        ));
-                    case 4 : {
+                        );
+                    case EditableConfigurationTarget.WORKSPACE_FOLDER: {
                         let workspaceFolderName = '<<unknown>>';
                         if (operation.resource) {
                             const folder = this.contextService.getWorkspaceFolder(operation.resource);
@@ -371,68 +396,68 @@ let ConfigurationEditing = class ConfigurationEditing {
                                 workspaceFolderName = folder.name;
                             }
                         }
-                        return ( localize(
-                            8977,
+                        return localize(
+                            11292,
                             "Unable to write into folder settings because the file has unsaved changes. Please save the '{0}' folder settings file first and then try again.",
                             workspaceFolderName
-                        ));
+                        );
                     }
                     default:
                         return '';
                 }
             }
-            case 10 :
+            case ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_MODIFIED_SINCE:
                 if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
-                    return ( localize(
-                        8978,
+                    return localize(
+                        11293,
                         "Unable to write into tasks configuration file because the content of the file is newer."
-                    ));
+                    );
                 }
                 if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
-                    return ( localize(
-                        8979,
+                    return localize(
+                        11294,
                         "Unable to write into launch configuration file because the content of the file is newer."
-                    ));
+                    );
                 }
                 switch (target) {
-                    case 1 :
-                        return ( localize(
-                            8980,
+                    case EditableConfigurationTarget.USER_LOCAL:
+                        return localize(
+                            11295,
                             "Unable to write into user settings because the content of the file is newer."
-                        ));
-                    case 2 :
-                        return ( localize(
-                            8981,
+                        );
+                    case EditableConfigurationTarget.USER_REMOTE:
+                        return localize(
+                            11296,
                             "Unable to write into remote user settings because the content of the file is newer."
-                        ));
-                    case 3 :
-                        return ( localize(
-                            8982,
+                        );
+                    case EditableConfigurationTarget.WORKSPACE:
+                        return localize(
+                            11297,
                             "Unable to write into workspace settings because the content of the file is newer."
-                        ));
-                    case 4 :
-                        return ( localize(
-                            8983,
+                        );
+                    case EditableConfigurationTarget.WORKSPACE_FOLDER:
+                        return localize(
+                            11298,
                             "Unable to write into folder settings because the content of the file is newer."
-                        ));
+                        );
                 }
-            case 13 : return ( localize(
-                8984,
+            case ConfigurationEditingErrorCode.ERROR_INTERNAL: return localize(
+                11299,
                 "Unable to write to {0} because of an internal error.",
                 this.stringifyTarget(target)
-            ));
+            );
         }
     }
     stringifyTarget(target) {
         switch (target) {
-            case 1 :
-                return ( localize(8985, "User Settings"));
-            case 2 :
-                return ( localize(8986, "Remote User Settings"));
-            case 3 :
-                return ( localize(8987, "Workspace Settings"));
-            case 4 :
-                return ( localize(8988, "Folder Settings"));
+            case EditableConfigurationTarget.USER_LOCAL:
+                return localize(11300, "User Settings");
+            case EditableConfigurationTarget.USER_REMOTE:
+                return localize(11301, "Remote User Settings");
+            case EditableConfigurationTarget.WORKSPACE:
+                return localize(11302, "Workspace Settings");
+            case EditableConfigurationTarget.WORKSPACE_FOLDER:
+                return localize(11303, "Folder Settings");
             default:
                 return '';
         }
@@ -462,60 +487,60 @@ let ConfigurationEditing = class ConfigurationEditing {
     }
     async validate(target, operation, checkDirty, overrides) {
         if (this.configurationService.inspect(operation.key).policyValue !== undefined) {
-            throw this.toConfigurationEditingError(12 , target, operation);
+            throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_POLICY_CONFIGURATION, target, operation);
         }
-        const configurationProperties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
+        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
         const configurationScope = configurationProperties[operation.key]?.scope;
         if (!operation.workspaceStandAloneConfigurationKey) {
-            const validKeys = ( (this.configurationService.keys())).default;
+            const validKeys = ( this.configurationService.keys()).default;
             if (validKeys.indexOf(operation.key) < 0 && !OVERRIDE_PROPERTY_REGEX.test(operation.key) && operation.value !== undefined) {
-                throw this.toConfigurationEditingError(0 , target, operation);
+                throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_UNKNOWN_KEY, target, operation);
             }
         }
         if (operation.workspaceStandAloneConfigurationKey) {
-            if ((operation.workspaceStandAloneConfigurationKey !== TASKS_CONFIGURATION_KEY) && ((target === 1  || target === 2) )) {
-                throw this.toConfigurationEditingError(4 , target, operation);
+            if ((operation.workspaceStandAloneConfigurationKey !== TASKS_CONFIGURATION_KEY) && (target === EditableConfigurationTarget.USER_LOCAL || target === EditableConfigurationTarget.USER_REMOTE)) {
+                throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_USER_TARGET, target, operation);
             }
         }
-        if (((target === 3  || target === 4) ) && this.contextService.getWorkbenchState() === 1 ) {
-            throw this.toConfigurationEditingError(8 , target, operation);
+        if ((target === EditableConfigurationTarget.WORKSPACE || target === EditableConfigurationTarget.WORKSPACE_FOLDER) && this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
+            throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_NO_WORKSPACE_OPENED, target, operation);
         }
-        if (target === 3 ) {
+        if (target === EditableConfigurationTarget.WORKSPACE) {
             if (!operation.workspaceStandAloneConfigurationKey && !OVERRIDE_PROPERTY_REGEX.test(operation.key)) {
-                if (configurationScope === 1 ) {
-                    throw this.toConfigurationEditingError(1 , target, operation);
+                if (configurationScope === ConfigurationScope.APPLICATION) {
+                    throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_APPLICATION, target, operation);
                 }
-                if (configurationScope === 2 ) {
-                    throw this.toConfigurationEditingError(2 , target, operation);
+                if (configurationScope === ConfigurationScope.MACHINE) {
+                    throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_CONFIGURATION_MACHINE, target, operation);
                 }
             }
         }
-        if (target === 4 ) {
+        if (target === EditableConfigurationTarget.WORKSPACE_FOLDER) {
             if (!operation.resource) {
-                throw this.toConfigurationEditingError(6 , target, operation);
+                throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_TARGET, target, operation);
             }
             if (!operation.workspaceStandAloneConfigurationKey && !OVERRIDE_PROPERTY_REGEX.test(operation.key)) {
                 if (configurationScope !== undefined && !FOLDER_SCOPES.includes(configurationScope)) {
-                    throw this.toConfigurationEditingError(3 , target, operation);
+                    throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_CONFIGURATION, target, operation);
                 }
             }
         }
         if (overrides.overrideIdentifiers?.length) {
-            if (configurationScope !== 5 ) {
-                throw this.toConfigurationEditingError(7 , target, operation);
+            if (configurationScope !== ConfigurationScope.LANGUAGE_OVERRIDABLE) {
+                throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_RESOURCE_LANGUAGE_CONFIGURATION, target, operation);
             }
         }
         if (!operation.resource) {
-            throw this.toConfigurationEditingError(6 , target, operation);
+            throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_TARGET, target, operation);
         }
         if (checkDirty && this.textFileService.isDirty(operation.resource)) {
-            throw this.toConfigurationEditingError(9 , target, operation);
+            throw this.toConfigurationEditingError(ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_DIRTY, target, operation);
         }
     }
     getConfigurationEditOperation(target, config, overrides) {
         if (config.key) {
-            const standaloneConfigurationMap = target === 1  ? USER_STANDALONE_CONFIGURATIONS : WORKSPACE_STANDALONE_CONFIGURATIONS;
-            const standaloneConfigurationKeys = ( (Object.keys(standaloneConfigurationMap)));
+            const standaloneConfigurationMap = target === EditableConfigurationTarget.USER_LOCAL ? USER_STANDALONE_CONFIGURATIONS : WORKSPACE_STANDALONE_CONFIGURATIONS;
+            const standaloneConfigurationKeys = ( Object.keys(standaloneConfigurationMap));
             for (const key of standaloneConfigurationKeys) {
                 const resource = this.getConfigurationFileResource(target, key, standaloneConfigurationMap[key], overrides.resource, undefined);
                 if (config.key === key) {
@@ -530,10 +555,10 @@ let ConfigurationEditing = class ConfigurationEditing {
             }
         }
         const key = config.key;
-        const configurationProperties = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
+        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
         const configurationScope = configurationProperties[key]?.scope;
         let jsonPath = overrides.overrideIdentifiers?.length ? [keyFromOverrideIdentifiers(overrides.overrideIdentifiers), key] : [key];
-        if (target === 1  || target === 2 ) {
+        if (target === EditableConfigurationTarget.USER_LOCAL || target === EditableConfigurationTarget.USER_REMOTE) {
             return { key, jsonPath, value: config.value, resource: this.getConfigurationFileResource(target, key, '', null, configurationScope) ?? undefined, target };
         }
         const resource = this.getConfigurationFileResource(target, key, FOLDER_SETTINGS_PATH, overrides.resource, configurationScope);
@@ -547,7 +572,7 @@ let ConfigurationEditing = class ConfigurationEditing {
         return !!(workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath);
     }
     getConfigurationFileResource(target, key, relativePath, resource, scope) {
-        if (target === 1 ) {
+        if (target === EditableConfigurationTarget.USER_LOCAL) {
             if (key === TASKS_CONFIGURATION_KEY) {
                 return this.userDataProfileService.currentProfile.tasksResource;
             }
@@ -558,21 +583,21 @@ let ConfigurationEditing = class ConfigurationEditing {
                 return this.userDataProfileService.currentProfile.settingsResource;
             }
         }
-        if (target === 2 ) {
+        if (target === EditableConfigurationTarget.USER_REMOTE) {
             return this.remoteSettingsResource;
         }
         const workbenchState = this.contextService.getWorkbenchState();
-        if (workbenchState !== 1 ) {
+        if (workbenchState !== WorkbenchState.EMPTY) {
             const workspace = this.contextService.getWorkspace();
-            if (target === 3 ) {
-                if (workbenchState === 3 ) {
+            if (target === EditableConfigurationTarget.WORKSPACE) {
+                if (workbenchState === WorkbenchState.WORKSPACE) {
                     return workspace.configuration ?? null;
                 }
-                if (workbenchState === 2 ) {
+                if (workbenchState === WorkbenchState.FOLDER) {
                     return workspace.folders[0].toResource(relativePath);
                 }
             }
-            if (target === 4 ) {
+            if (target === EditableConfigurationTarget.WORKSPACE_FOLDER) {
                 if (resource) {
                     const folder = this.contextService.getWorkspaceFolder(resource);
                     if (folder) {
@@ -584,18 +609,18 @@ let ConfigurationEditing = class ConfigurationEditing {
         return null;
     }
 };
-ConfigurationEditing = ( (__decorate([
-    ( (__param(1, IWorkbenchConfigurationService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IUserDataProfileService))),
-    ( (__param(4, IUserDataProfilesService))),
-    ( (__param(5, IFileService))),
-    ( (__param(6, ITextModelService))),
-    ( (__param(7, ITextFileService))),
-    ( (__param(8, INotificationService))),
-    ( (__param(9, IPreferencesService))),
-    ( (__param(10, IEditorService))),
-    ( (__param(11, IUriIdentityService)))
-], ConfigurationEditing)));
+ConfigurationEditing = ( __decorate([
+    ( __param(1, IWorkbenchConfigurationService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IUserDataProfileService)),
+    ( __param(4, IUserDataProfilesService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, ITextFileService)),
+    ( __param(8, INotificationService)),
+    ( __param(9, IPreferencesService)),
+    ( __param(10, IEditorService)),
+    ( __param(11, IUriIdentityService))
+], ConfigurationEditing));
 
-export { ConfigurationEditing, ConfigurationEditingError };
+export { ConfigurationEditing, ConfigurationEditingError, ConfigurationEditingErrorCode, EditableConfigurationTarget };