@codingame/monaco-vscode-user-data-profile-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/userDataProfile/browser/mcpProfileResource.js

@@ -24,14 +24,13 @@ let McpResourceInitializer = class McpResourceInitializer {
             this.logService.info(`Initializing Profile: No MCP servers to apply...`);
             return;
         }
-        await this.fileService.writeFile(this.userDataProfileService.currentProfile.mcpResource, VSBuffer.fromString(mcpContent.mcp));
+        await this.fileService.writeFile(
+            this.userDataProfileService.currentProfile.mcpResource,
+            VSBuffer.fromString(mcpContent.mcp)
+        );
     }
 };
-McpResourceInitializer = ( __decorate([
-    ( __param(0, IUserDataProfileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILogService))
-], McpResourceInitializer));
+McpResourceInitializer = ( __decorate([( __param(0, IUserDataProfileService)), ( __param(1, IFileService)), ( __param(2, ILogService))], McpResourceInitializer));
 let McpProfileResource = class McpProfileResource {
     constructor(fileService, logService) {
         this.fileService = fileService;
@@ -43,7 +42,9 @@ let McpProfileResource = class McpProfileResource {
     }
     async getMcpResourceContent(profile) {
         const mcpContent = await this.getMcpContent(profile);
-        return { mcp: mcpContent };
+        return {
+            mcp: mcpContent
+        };
     }
     async apply(content, profile) {
         const mcpContent = JSON.parse(content);
@@ -57,21 +58,16 @@ let McpProfileResource = class McpProfileResource {
         try {
             const content = await this.fileService.readFile(profile.mcpResource);
             return ( content.value.toString());
-        }
-        catch (error) {
+        } catch (error) {
             if (error instanceof FileOperationError && error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
                 return null;
-            }
-            else {
+            } else {
                 throw error;
             }
         }
     }
 };
-McpProfileResource = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ILogService))
-], McpProfileResource));
+McpProfileResource = ( __decorate([( __param(0, IFileService)), ( __param(1, ILogService))], McpProfileResource));
 let McpResourceTreeItem = class McpResourceTreeItem {
     constructor(profile, uriIdentityService, instantiationService) {
         this.profile = profile;
@@ -79,24 +75,26 @@ let McpResourceTreeItem = class McpResourceTreeItem {
         this.instantiationService = instantiationService;
         this.type = ProfileResourceType.Mcp;
         this.handle = ProfileResourceType.Mcp;
-        this.label = { label: ( localize(14517, "MCP Servers")) };
+        this.label = {
+            label: ( localize(14914, "MCP Servers"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
     }
     async getChildren() {
         return [{
-                handle: ( this.profile.mcpResource.toString()),
-                resourceUri: this.profile.mcpResource,
-                collapsibleState: TreeItemCollapsibleState.None,
-                parent: this,
-                accessibilityInformation: {
-                    label: this.uriIdentityService.extUri.basename(this.profile.mcpResource)
-                },
-                command: {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [this.profile.mcpResource, undefined, undefined]
-                }
-            }];
+            handle: ( this.profile.mcpResource.toString()),
+            resourceUri: this.profile.mcpResource,
+            collapsibleState: TreeItemCollapsibleState.None,
+            parent: this,
+            accessibilityInformation: {
+                label: this.uriIdentityService.extUri.basename(this.profile.mcpResource)
+            },
+            command: {
+                id: API_OPEN_EDITOR_COMMAND_ID,
+                title: "",
+                arguments: [this.profile.mcpResource, undefined, undefined]
+            }
+        }];
     }
     async hasContent() {
         const mcpContent = await this.instantiationService.createInstance(McpProfileResource).getMcpResourceContent(this.profile);
@@ -109,9 +107,6 @@ let McpResourceTreeItem = class McpResourceTreeItem {
         return !this.profile.isDefault && !!this.profile.useDefaultFlags?.mcp;
     }
 };
-McpResourceTreeItem = ( __decorate([
-    ( __param(1, IUriIdentityService)),
-    ( __param(2, IInstantiationService))
-], McpResourceTreeItem));
+McpResourceTreeItem = ( __decorate([( __param(1, IUriIdentityService)), ( __param(2, IInstantiationService))], McpResourceTreeItem));
 
 export { McpProfileResource, McpResourceInitializer, McpResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/settingsResource.js

@@ -28,14 +28,13 @@ let SettingsResourceInitializer = class SettingsResourceInitializer {
             this.logService.info(`Initializing Profile: No settings to apply...`);
             return;
         }
-        await this.fileService.writeFile(this.userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString(settingsContent.settings));
+        await this.fileService.writeFile(
+            this.userDataProfileService.currentProfile.settingsResource,
+            VSBuffer.fromString(settingsContent.settings)
+        );
     }
 };
-SettingsResourceInitializer = ( __decorate([
-    ( __param(0, IUserDataProfileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILogService))
-], SettingsResourceInitializer));
+SettingsResourceInitializer = ( __decorate([( __param(0, IUserDataProfileService)), ( __param(1, IFileService)), ( __param(2, ILogService))], SettingsResourceInitializer));
 let SettingsResource = class SettingsResource {
     constructor(fileService, userDataSyncUtilService, logService) {
         this.fileService = fileService;
@@ -49,13 +48,16 @@ let SettingsResource = class SettingsResource {
     async getSettingsContent(profile) {
         const localContent = await this.getLocalFileContent(profile);
         if (localContent === null) {
-            return { settings: null };
-        }
-        else {
+            return {
+                settings: null
+            };
+        } else {
             const ignoredSettings = this.getIgnoredSettings();
             const formattingOptions = await this.userDataSyncUtilService.resolveFormattingOptions(profile.settingsResource);
-            const settings = updateIgnoredSettings(localContent || '{}', '{}', ignoredSettings, formattingOptions);
-            return { settings };
+            const settings = updateIgnoredSettings(localContent || "{}", "{}", ignoredSettings, formattingOptions);
+            return {
+                settings
+            };
         }
     }
     async apply(content, profile) {
@@ -66,34 +68,35 @@ let SettingsResource = class SettingsResource {
         }
         const localSettingsContent = await this.getLocalFileContent(profile);
         const formattingOptions = await this.userDataSyncUtilService.resolveFormattingOptions(profile.settingsResource);
-        const contentToUpdate = updateIgnoredSettings(settingsContent.settings, localSettingsContent || '{}', this.getIgnoredSettings(), formattingOptions);
+        const contentToUpdate = updateIgnoredSettings(
+            settingsContent.settings,
+            localSettingsContent || "{}",
+            this.getIgnoredSettings(),
+            formattingOptions
+        );
         await this.fileService.writeFile(profile.settingsResource, VSBuffer.fromString(contentToUpdate));
     }
     getIgnoredSettings() {
         const allSettings = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-        const ignoredSettings = ( Object.keys(allSettings)).filter(key => allSettings[key]?.scope === ConfigurationScope.MACHINE || allSettings[key]?.scope === ConfigurationScope.APPLICATION_MACHINE || allSettings[key]?.scope === ConfigurationScope.MACHINE_OVERRIDABLE);
+        const ignoredSettings = ( Object.keys(allSettings)).filter(
+            key => allSettings[key]?.scope === ConfigurationScope.MACHINE || allSettings[key]?.scope === ConfigurationScope.APPLICATION_MACHINE || allSettings[key]?.scope === ConfigurationScope.MACHINE_OVERRIDABLE
+        );
         return ignoredSettings;
     }
     async getLocalFileContent(profile) {
         try {
             const content = await this.fileService.readFile(profile.settingsResource);
             return ( content.value.toString());
-        }
-        catch (error) {
+        } catch (error) {
             if (error instanceof FileOperationError && error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
                 return null;
-            }
-            else {
+            } else {
                 throw error;
             }
         }
     }
 };
-SettingsResource = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IUserDataSyncUtilService)),
-    ( __param(2, ILogService))
-], SettingsResource));
+SettingsResource = ( __decorate([( __param(0, IFileService)), ( __param(1, IUserDataSyncUtilService)), ( __param(2, ILogService))], SettingsResource));
 let SettingsResourceTreeItem = class SettingsResourceTreeItem {
     constructor(profile, uriIdentityService, instantiationService) {
         this.profile = profile;
@@ -101,24 +104,26 @@ let SettingsResourceTreeItem = class SettingsResourceTreeItem {
         this.instantiationService = instantiationService;
         this.type = ProfileResourceType.Settings;
         this.handle = ProfileResourceType.Settings;
-        this.label = { label: ( localize(14518, "Settings")) };
+        this.label = {
+            label: ( localize(14915, "Settings"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
     }
     async getChildren() {
         return [{
-                handle: ( this.profile.settingsResource.toString()),
-                resourceUri: this.profile.settingsResource,
-                collapsibleState: TreeItemCollapsibleState.None,
-                parent: this,
-                accessibilityInformation: {
-                    label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
-                },
-                command: {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [this.profile.settingsResource, undefined, undefined]
-                }
-            }];
+            handle: ( this.profile.settingsResource.toString()),
+            resourceUri: this.profile.settingsResource,
+            collapsibleState: TreeItemCollapsibleState.None,
+            parent: this,
+            accessibilityInformation: {
+                label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
+            },
+            command: {
+                id: API_OPEN_EDITOR_COMMAND_ID,
+                title: "",
+                arguments: [this.profile.settingsResource, undefined, undefined]
+            }
+        }];
     }
     async hasContent() {
         const settingsContent = await this.instantiationService.createInstance(SettingsResource).getSettingsContent(this.profile);
@@ -131,9 +136,6 @@ let SettingsResourceTreeItem = class SettingsResourceTreeItem {
         return !this.profile.isDefault && !!this.profile.useDefaultFlags?.settings;
     }
 };
-SettingsResourceTreeItem = ( __decorate([
-    ( __param(1, IUriIdentityService)),
-    ( __param(2, IInstantiationService))
-], SettingsResourceTreeItem));
+SettingsResourceTreeItem = ( __decorate([( __param(1, IUriIdentityService)), ( __param(2, IInstantiationService))], SettingsResourceTreeItem));
 
 export { SettingsResource, SettingsResourceInitializer, SettingsResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/snippetsResource.js

@@ -26,11 +26,7 @@ let SnippetsResourceInitializer = class SnippetsResourceInitializer {
         }
     }
 };
-SnippetsResourceInitializer = ( __decorate([
-    ( __param(0, IUserDataProfileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IUriIdentityService))
-], SnippetsResourceInitializer));
+SnippetsResourceInitializer = ( __decorate([( __param(0, IUserDataProfileService)), ( __param(1, IFileService)), ( __param(2, IUriIdentityService))], SnippetsResourceInitializer));
 let SnippetsResource = class SnippetsResource {
     constructor(fileService, uriIdentityService) {
         this.fileService = fileService;
@@ -38,7 +34,9 @@ let SnippetsResource = class SnippetsResource {
     }
     async getContent(profile, excluded) {
         const snippets = await this.getSnippets(profile, excluded);
-        return JSON.stringify({ snippets });
+        return JSON.stringify({
+            snippets
+        });
     }
     async apply(content, profile) {
         const snippetsContent = JSON.parse(content);
@@ -62,38 +60,37 @@ let SnippetsResource = class SnippetsResource {
         let stat;
         try {
             stat = await this.fileService.resolve(profile.snippetsHome);
-        }
-        catch (e) {
+        } catch (e) {
             if (e instanceof FileOperationError && e.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
                 return snippets;
-            }
-            else {
+            } else {
                 throw e;
             }
         }
-        for (const { resource } of stat.children || []) {
+        for (const {
+            resource
+        } of stat.children || []) {
             if (excluded?.has(resource)) {
                 continue;
             }
             const extension = this.uriIdentityService.extUri.extname(resource);
-            if (extension === '.json' || extension === '.code-snippets') {
+            if (extension === ".json" || extension === ".code-snippets") {
                 snippets.push(resource);
             }
         }
         return snippets;
     }
 };
-SnippetsResource = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IUriIdentityService))
-], SnippetsResource));
+SnippetsResource = ( __decorate([( __param(0, IFileService)), ( __param(1, IUriIdentityService))], SnippetsResource));
 let SnippetsResourceTreeItem = class SnippetsResourceTreeItem {
     constructor(profile, instantiationService, uriIdentityService) {
         this.profile = profile;
         this.instantiationService = instantiationService;
         this.uriIdentityService = uriIdentityService;
         this.type = ProfileResourceType.Snippets;
-        this.label = { label: ( localize(14519, "Snippets")) };
+        this.label = {
+            label: ( localize(14916, "Snippets"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Collapsed;
         this.excludedSnippets = ( new ResourceSet());
         this.handle = ( this.profile.snippetsHome.toString());
@@ -107,29 +104,30 @@ let SnippetsResourceTreeItem = class SnippetsResourceTreeItem {
             resourceUri: resource,
             collapsibleState: TreeItemCollapsibleState.None,
             accessibilityInformation: {
-                label: this.uriIdentityService.extUri.basename(resource),
+                label: this.uriIdentityService.extUri.basename(resource)
             },
             checkbox: that.checkbox ? {
-                get isChecked() { return !( that.excludedSnippets.has(resource)); },
+                get isChecked() {
+                    return !( that.excludedSnippets.has(resource));
+                },
                 set isChecked(value) {
                     if (value) {
                         that.excludedSnippets.delete(resource);
-                    }
-                    else {
+                    } else {
                         that.excludedSnippets.add(resource);
                     }
                 },
                 accessibilityInformation: {
                     label: ( localize(
-                        14520,
+                        14917,
                         "Select Snippet {0}",
                         this.uriIdentityService.extUri.basename(resource)
-                    )),
+                    ))
                 }
             } : undefined,
             command: {
                 id: API_OPEN_EDITOR_COMMAND_ID,
-                title: '',
+                title: "",
                 arguments: [resource, undefined, undefined]
             }
         })));
@@ -145,9 +143,6 @@ let SnippetsResourceTreeItem = class SnippetsResourceTreeItem {
         return !this.profile.isDefault && !!this.profile.useDefaultFlags?.snippets;
     }
 };
-SnippetsResourceTreeItem = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IUriIdentityService))
-], SnippetsResourceTreeItem));
+SnippetsResourceTreeItem = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IUriIdentityService))], SnippetsResourceTreeItem));
 
 export { SnippetsResource, SnippetsResourceInitializer, SnippetsResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/tasksResource.js

@@ -24,14 +24,13 @@ let TasksResourceInitializer = class TasksResourceInitializer {
             this.logService.info(`Initializing Profile: No tasks to apply...`);
             return;
         }
-        await this.fileService.writeFile(this.userDataProfileService.currentProfile.tasksResource, VSBuffer.fromString(tasksContent.tasks));
+        await this.fileService.writeFile(
+            this.userDataProfileService.currentProfile.tasksResource,
+            VSBuffer.fromString(tasksContent.tasks)
+        );
     }
 };
-TasksResourceInitializer = ( __decorate([
-    ( __param(0, IUserDataProfileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILogService))
-], TasksResourceInitializer));
+TasksResourceInitializer = ( __decorate([( __param(0, IUserDataProfileService)), ( __param(1, IFileService)), ( __param(2, ILogService))], TasksResourceInitializer));
 let TasksResource = class TasksResource {
     constructor(fileService, logService) {
         this.fileService = fileService;
@@ -43,7 +42,9 @@ let TasksResource = class TasksResource {
     }
     async getTasksResourceContent(profile) {
         const tasksContent = await this.getTasksContent(profile);
-        return { tasks: tasksContent };
+        return {
+            tasks: tasksContent
+        };
     }
     async apply(content, profile) {
         const tasksContent = JSON.parse(content);
@@ -57,21 +58,16 @@ let TasksResource = class TasksResource {
         try {
             const content = await this.fileService.readFile(profile.tasksResource);
             return ( content.value.toString());
-        }
-        catch (error) {
+        } catch (error) {
             if (error instanceof FileOperationError && error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
                 return null;
-            }
-            else {
+            } else {
                 throw error;
             }
         }
     }
 };
-TasksResource = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ILogService))
-], TasksResource));
+TasksResource = ( __decorate([( __param(0, IFileService)), ( __param(1, ILogService))], TasksResource));
 let TasksResourceTreeItem = class TasksResourceTreeItem {
     constructor(profile, uriIdentityService, instantiationService) {
         this.profile = profile;
@@ -79,24 +75,26 @@ let TasksResourceTreeItem = class TasksResourceTreeItem {
         this.instantiationService = instantiationService;
         this.type = ProfileResourceType.Tasks;
         this.handle = ProfileResourceType.Tasks;
-        this.label = { label: ( localize(14521, "Tasks")) };
+        this.label = {
+            label: ( localize(14918, "Tasks"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
     }
     async getChildren() {
         return [{
-                handle: ( this.profile.tasksResource.toString()),
-                resourceUri: this.profile.tasksResource,
-                collapsibleState: TreeItemCollapsibleState.None,
-                parent: this,
-                accessibilityInformation: {
-                    label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
-                },
-                command: {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [this.profile.tasksResource, undefined, undefined]
-                }
-            }];
+            handle: ( this.profile.tasksResource.toString()),
+            resourceUri: this.profile.tasksResource,
+            collapsibleState: TreeItemCollapsibleState.None,
+            parent: this,
+            accessibilityInformation: {
+                label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
+            },
+            command: {
+                id: API_OPEN_EDITOR_COMMAND_ID,
+                title: "",
+                arguments: [this.profile.tasksResource, undefined, undefined]
+            }
+        }];
     }
     async hasContent() {
         const tasksContent = await this.instantiationService.createInstance(TasksResource).getTasksResourceContent(this.profile);
@@ -109,9 +107,6 @@ let TasksResourceTreeItem = class TasksResourceTreeItem {
         return !this.profile.isDefault && !!this.profile.useDefaultFlags?.tasks;
     }
 };
-TasksResourceTreeItem = ( __decorate([
-    ( __param(1, IUriIdentityService)),
-    ( __param(2, IInstantiationService))
-], TasksResourceTreeItem));
+TasksResourceTreeItem = ( __decorate([( __param(1, IUriIdentityService)), ( __param(2, IInstantiationService))], TasksResourceTreeItem));
 
 export { TasksResource, TasksResourceInitializer, TasksResourceTreeItem };