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

package/vscode/src/vs/workbench/services/label/common/labelService.js

@@ -24,14 +24,11 @@ import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storag
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
 import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 
+const _moduleId = "vs/workbench/services/label/common/labelService";
 const resourceLabelFormattersExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'resourceLabelFormatters',
     jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/services/label/common/labelService',
-            'vscode.extension.contributes.resourceLabelFormatters',
-            'Contributes resource label formatting rules.'
-        )),
+        description: ( localizeWithPath(_moduleId, 0, 'Contributes resource label formatting rules.')),
         type: 'array',
         items: {
             type: 'object',
@@ -40,66 +37,58 @@ const resourceLabelFormattersExtPoint = ExtensionsRegistry.registerExtensionPoin
                 scheme: {
                     type: 'string',
                     description: ( localizeWithPath(
-                        'vs/workbench/services/label/common/labelService',
-                        'vscode.extension.contributes.resourceLabelFormatters.scheme',
+                        _moduleId,
+                        1,
                         'URI scheme on which to match the formatter on. For example "file". Simple glob patterns are supported.'
                     )),
                 },
                 authority: {
                     type: 'string',
                     description: ( localizeWithPath(
-                        'vs/workbench/services/label/common/labelService',
-                        'vscode.extension.contributes.resourceLabelFormatters.authority',
+                        _moduleId,
+                        2,
                         'URI authority on which to match the formatter on. Simple glob patterns are supported.'
                     )),
                 },
                 formatting: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/label/common/labelService',
-                        'vscode.extension.contributes.resourceLabelFormatters.formatting',
-                        "Rules for formatting uri resource labels."
-                    )),
+                    description: ( localizeWithPath(_moduleId, 3, "Rules for formatting uri resource labels.")),
                     type: 'object',
                     properties: {
                         label: {
                             type: 'string',
                             description: ( localizeWithPath(
-                                'vs/workbench/services/label/common/labelService',
-                                'vscode.extension.contributes.resourceLabelFormatters.label',
+                                _moduleId,
+                                4,
                                 "Label rules to display. For example: myLabel:/${path}. ${path}, ${scheme}, ${authority} and ${authoritySuffix} are supported as variables."
                             ))
                         },
                         separator: {
                             type: 'string',
                             description: ( localizeWithPath(
-                                'vs/workbench/services/label/common/labelService',
-                                'vscode.extension.contributes.resourceLabelFormatters.separator',
+                                _moduleId,
+                                5,
                                 "Separator to be used in the uri label display. '/' or '\' as an example."
                             ))
                         },
                         stripPathStartingSeparator: {
                             type: 'boolean',
                             description: ( localizeWithPath(
-                                'vs/workbench/services/label/common/labelService',
-                                'vscode.extension.contributes.resourceLabelFormatters.stripPathStartingSeparator',
+                                _moduleId,
+                                6,
                                 "Controls whether `${path}` substitutions should have starting separator characters stripped."
                             ))
                         },
                         tildify: {
                             type: 'boolean',
                             description: ( localizeWithPath(
-                                'vs/workbench/services/label/common/labelService',
-                                'vscode.extension.contributes.resourceLabelFormatters.tildify',
+                                _moduleId,
+                                7,
                                 "Controls if the start of the uri label should be tildified when possible."
                             ))
                         },
                         workspaceSuffix: {
                             type: 'string',
-                            description: ( localizeWithPath(
-                                'vs/workbench/services/label/common/labelService',
-                                'vscode.extension.contributes.resourceLabelFormatters.formatting.workspaceSuffix',
-                                "Suffix appended to the workspace label."
-                            ))
+                            description: ( localizeWithPath(_moduleId, 8, "Suffix appended to the workspace label."))
                         }
                     }
                 }
@@ -114,7 +103,7 @@ function hasDriveLetterIgnorePlatform(path) {
 }
 let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
     constructor(labelService) {
-        this.formattersDisposables = ( new Map());
+        this.formattersDisposables = ( (new Map()));
         resourceLabelFormattersExtPoint.setHandler((extensions, delta) => {
             for (const added of delta.added) {
                 for (const untrustedFormatter of added.value) {
@@ -139,10 +128,10 @@ let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
         });
     }
 };
-ResourceLabelFormattersHandler = ( __decorate([
-    ( __param(0, ILabelService))
-], ResourceLabelFormattersHandler));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ResourceLabelFormattersHandler, 3 );
+ResourceLabelFormattersHandler = ( (__decorate([
+    ( (__param(0, ILabelService)))
+], ResourceLabelFormattersHandler)));
+( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(ResourceLabelFormattersHandler, 3 );
 const FORMATTER_CACHE_SIZE = 50;
 let LabelService = class LabelService extends Disposable {
     constructor(environmentService, contextService, pathService, remoteAgentService, storageService, lifecycleService) {
@@ -151,11 +140,11 @@ let LabelService = class LabelService extends Disposable {
         this.contextService = contextService;
         this.pathService = pathService;
         this.remoteAgentService = remoteAgentService;
-        this._onDidChangeFormatters = this._register(( new Emitter({ leakWarningThreshold: 400 })));
+        this._onDidChangeFormatters = this._register(( (new Emitter({ leakWarningThreshold: 400 }))));
         this.onDidChangeFormatters = this._onDidChangeFormatters.event;
         this.os = OS;
         this.userHome = pathService.defaultUriScheme === Schemas.file ? this.pathService.userHome({ preferLocal: true }) : undefined;
-        const memento = this.storedFormattersMemento = ( new Memento('cachedResourceLabelFormatters2', storageService));
+        const memento = this.storedFormattersMemento = ( (new Memento('cachedResourceLabelFormatters2', storageService)));
         this.storedFormatters = memento.getMemento(0 , 1 );
         this.formatters = this.storedFormatters?.formatters?.slice() || [];
         this.resolveRemoteEnvironment();
@@ -278,18 +267,10 @@ let LabelService = class LabelService extends Disposable {
     }
     doGetWorkspaceLabel(workspaceUri, options) {
         if (isUntitledWorkspace(workspaceUri, this.environmentService)) {
-            return ( localizeWithPath(
-                'vs/workbench/services/label/common/labelService',
-                'untitledWorkspace',
-                "Untitled (Workspace)"
-            ));
+            return ( localizeWithPath(_moduleId, 9, "Untitled (Workspace)"));
         }
         if (isTemporaryWorkspace(workspaceUri)) {
-            return ( localizeWithPath(
-                'vs/workbench/services/label/common/labelService',
-                'temporaryWorkspace',
-                "Workspace"
-            ));
+            return ( localizeWithPath(_moduleId, 10, "Workspace"));
         }
         let filename = basename(workspaceUri);
         if (filename.endsWith(WORKSPACE_EXTENSION)) {
@@ -302,20 +283,15 @@ let LabelService = class LabelService extends Disposable {
                 break;
             case 2 :
                 label = ( localizeWithPath(
-                    'vs/workbench/services/label/common/labelService',
-                    'workspaceNameVerbose',
+                    _moduleId,
+                    11,
                     "{0} (Workspace)",
                     this.getUriLabel(joinPath(dirname(workspaceUri), filename))
                 ));
                 break;
             case 1 :
             default:
-                label = ( localizeWithPath(
-                    'vs/workbench/services/label/common/labelService',
-                    'workspaceName',
-                    "{0} (Workspace)",
-                    filename
-                ));
+                label = ( localizeWithPath(_moduleId, 12, "{0} (Workspace)", filename));
                 break;
         }
         if (options?.verbose === 0 ) {
@@ -341,15 +317,15 @@ let LabelService = class LabelService extends Disposable {
         return this.appendWorkspaceSuffix(label, folderUri);
     }
     getSeparator(scheme, authority) {
-        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        const formatter = this.findFormatting(( (URI.from({ scheme, authority }))));
         return formatter?.separator || posix.sep;
     }
     getHostLabel(scheme, authority) {
-        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        const formatter = this.findFormatting(( (URI.from({ scheme, authority }))));
         return formatter?.workspaceSuffix || authority || '';
     }
     getHostTooltip(scheme, authority) {
-        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        const formatter = this.findFormatting(( (URI.from({ scheme, authority }))));
         return formatter?.workspaceTooltip;
     }
     registerCachedFormatter(formatter) {
@@ -426,13 +402,13 @@ let LabelService = class LabelService extends Disposable {
         return suffix ? `${label} [${suffix}]` : label;
     }
 };
-LabelService = ( __decorate([
-    ( __param(0, IWorkbenchEnvironmentService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IPathService)),
-    ( __param(3, IRemoteAgentService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, ILifecycleService))
-], LabelService));
+LabelService = ( (__decorate([
+    ( (__param(0, IWorkbenchEnvironmentService))),
+    ( (__param(1, IWorkspaceContextService))),
+    ( (__param(2, IPathService))),
+    ( (__param(3, IRemoteAgentService))),
+    ( (__param(4, IStorageService))),
+    ( (__param(5, ILifecycleService)))
+], LabelService)));
 
 export { LabelService };

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

@@ -26,6 +26,7 @@ import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProf
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
+const _moduleId = "vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService";
 let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
     constructor(jsonEditingService, contextService, configurationService, notificationService, commandService, fileService, textFileService, workspacesService, environmentService, fileDialogService, dialogService, hostService, uriIdentityService, workspaceTrustManagementService, userDataProfilesService, userDataProfileService) {
         this.jsonEditingService = jsonEditingService;
@@ -51,16 +52,8 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
             availableFileSystems.unshift(Schemas.vscodeRemote);
         }
         let workspacePath = await this.fileDialogService.showSaveDialog({
-            saveLabel: mnemonicButtonLabel(( localizeWithPath(
-                'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-                'save',
-                "Save"
-            ))),
-            title: ( localizeWithPath(
-                'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-                'saveWorkspace',
-                "Save Workspace"
-            )),
+            saveLabel: mnemonicButtonLabel(( localizeWithPath(_moduleId, 0, "Save"))),
+            title: ( localizeWithPath(_moduleId, 1, "Save Workspace")),
             filters: WORKSPACE_FILTER,
             defaultUri: joinPath(await this.fileDialogService.defaultWorkspacePath(), this.getNewWorkspaceName()),
             availableFileSystems
@@ -88,13 +81,13 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
         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;
@@ -129,15 +122,15 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
         }
     }
     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 })));
+            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) {
@@ -172,9 +165,11 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
     includesSingleFolderWorkspace(folders) {
         if (this.contextService.getWorkbenchState() === 2 ) {
             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;
     }
@@ -229,7 +224,7 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
         }
         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);
     }
@@ -259,25 +254,21 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
     }
     onInvalidWorkspaceConfigurationFileError() {
         const message = ( localizeWithPath(
-            'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-            'errorInvalidTaskConfiguration',
+            _moduleId,
+            2,
             "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: ( localizeWithPath(
-                    'vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService',
-                    'openWorkspaceConfigurationFile',
-                    "Open Workspace Configuration"
-                )),
+                label: ( localizeWithPath(_moduleId, 3, "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 ) {
@@ -293,9 +284,9 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
         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;
@@ -318,23 +309,23 @@ let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
         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/configuration.d.ts

@@ -1,29 +0,0 @@
-import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
-import { IConfigurationRegistry } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-export { ConfigurationScope, IConfigurationDefaults, IConfigurationNode } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { IFileWriteOptions } from 'vscode/vscode/vs/platform/files/common/files';
-import { IAnyWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-export { IAnyWorkspaceIdentifier, IEmptyWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-
-declare const defaultUserConfigurationFile: URI;
-/**
- * Should be called only BEFORE the service are initialized to initialize the file on the filesystem before the configuration service initializes
- */
-declare function initUserConfiguration(configurationJson: string, options?: Partial<IFileWriteOptions>, file?: URI): Promise<void>;
-/**
- * Can be called at any time after the services are initialized to update the user configuration
- */
-declare function updateUserConfiguration(configurationJson: string): Promise<void>;
-declare function getUserConfiguration(): Promise<string>;
-declare function onUserConfigurationChange(callback: () => void): IDisposable;
-declare const configurationRegistry: IConfigurationRegistry;
-declare function reinitializeWorkspace(workspace: IAnyWorkspaceIdentifier): Promise<void>;
-declare function getServiceOverride(): IEditorOverrideServices;
-/**
- * @deprecated Provide workspace via the services `initialize` function `configuration.workspaceProvider` parameter
- */
-declare function getServiceOverride(defaultWorkspace?: URI | IAnyWorkspaceIdentifier): IEditorOverrideServices;
-
-export { configurationRegistry, getServiceOverride as default, defaultUserConfigurationFile, getUserConfiguration, initUserConfiguration, onUserConfigurationChange, reinitializeWorkspace, updateUserConfiguration };