@codingame/monaco-vscode-user-data-sync-service-override 1.85.2

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

@@ -0,0 +1,140 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { updateIgnoredSettings } from 'vscode/vscode/vs/platform/userDataSync/common/settingsMerge';
+import { IUserDataSyncUtilService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+
+let SettingsResourceInitializer = class SettingsResourceInitializer {
+    constructor(userDataProfileService, fileService, logService) {
+        this.userDataProfileService = userDataProfileService;
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async initialize(content) {
+        const settingsContent = JSON.parse(content);
+        if (settingsContent.settings === null) {
+            this.logService.info(`Initializing Profile: No settings to apply...`);
+            return;
+        }
+        await this.fileService.writeFile(this.userDataProfileService.currentProfile.settingsResource, VSBuffer.fromString(settingsContent.settings));
+    }
+};
+SettingsResourceInitializer = ( __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
+], SettingsResourceInitializer));
+let SettingsResource = class SettingsResource {
+    constructor(fileService, userDataSyncUtilService, logService) {
+        this.fileService = fileService;
+        this.userDataSyncUtilService = userDataSyncUtilService;
+        this.logService = logService;
+    }
+    async getContent(profile) {
+        const settingsContent = await this.getSettingsContent(profile);
+        return JSON.stringify(settingsContent);
+    }
+    async getSettingsContent(profile) {
+        const localContent = await this.getLocalFileContent(profile);
+        if (localContent === null) {
+            return { settings: null };
+        }
+        else {
+            const ignoredSettings = this.getIgnoredSettings();
+            const formattingOptions = await this.userDataSyncUtilService.resolveFormattingOptions(profile.settingsResource);
+            const settings = updateIgnoredSettings(localContent || '{}', '{}', ignoredSettings, formattingOptions);
+            return { settings };
+        }
+    }
+    async apply(content, profile) {
+        const settingsContent = JSON.parse(content);
+        if (settingsContent.settings === null) {
+            this.logService.info(`Importing Profile (${profile.name}): No settings to apply...`);
+            return;
+        }
+        const localSettingsContent = await this.getLocalFileContent(profile);
+        const formattingOptions = await this.userDataSyncUtilService.resolveFormattingOptions(profile.settingsResource);
+        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 === 2  || allSettings[key]?.scope === 6 );
+        return ignoredSettings;
+    }
+    async getLocalFileContent(profile) {
+        try {
+            const content = await this.fileService.readFile(profile.settingsResource);
+            return ( content.value.toString());
+        }
+        catch (error) {
+            if (error instanceof FileOperationError && error.fileOperationResult === 1 ) {
+                return null;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+};
+SettingsResource = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUserDataSyncUtilService)),
+    ( __param(2, ILogService))
+], SettingsResource));
+let SettingsResourceTreeItem = class SettingsResourceTreeItem {
+    constructor(profile, uriIdentityService, instantiationService) {
+        this.profile = profile;
+        this.uriIdentityService = uriIdentityService;
+        this.instantiationService = instantiationService;
+        this.type = "settings" ;
+        this.handle = "settings" ;
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/settingsResource',
+            'settings',
+            "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]
+                }
+            }];
+    }
+    async hasContent() {
+        const settingsContent = await this.instantiationService.createInstance(SettingsResource).getSettingsContent(this.profile);
+        return settingsContent.settings !== null;
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(SettingsResource).getContent(this.profile);
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.settings;
+    }
+};
+SettingsResourceTreeItem = ( __decorate([
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, IInstantiationService))
+], SettingsResourceTreeItem));
+
+export { SettingsResource, SettingsResourceInitializer, SettingsResourceTreeItem };

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

@@ -0,0 +1,155 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+let SnippetsResourceInitializer = class SnippetsResourceInitializer {
+    constructor(userDataProfileService, fileService, uriIdentityService) {
+        this.userDataProfileService = userDataProfileService;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+    }
+    async initialize(content) {
+        const snippetsContent = JSON.parse(content);
+        for (const key in snippetsContent.snippets) {
+            const resource = this.uriIdentityService.extUri.joinPath(this.userDataProfileService.currentProfile.snippetsHome, key);
+            await this.fileService.writeFile(resource, VSBuffer.fromString(snippetsContent.snippets[key]));
+        }
+    }
+};
+SnippetsResourceInitializer = ( __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUriIdentityService))
+], SnippetsResourceInitializer));
+let SnippetsResource = class SnippetsResource {
+    constructor(fileService, uriIdentityService) {
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+    }
+    async getContent(profile, excluded) {
+        const snippets = await this.getSnippets(profile, excluded);
+        return JSON.stringify({ snippets });
+    }
+    async apply(content, profile) {
+        const snippetsContent = JSON.parse(content);
+        for (const key in snippetsContent.snippets) {
+            const resource = this.uriIdentityService.extUri.joinPath(profile.snippetsHome, key);
+            await this.fileService.writeFile(resource, VSBuffer.fromString(snippetsContent.snippets[key]));
+        }
+    }
+    async getSnippets(profile, excluded) {
+        const snippets = {};
+        const snippetsResources = await this.getSnippetsResources(profile, excluded);
+        for (const resource of snippetsResources) {
+            const key = this.uriIdentityService.extUri.relativePath(profile.snippetsHome, resource);
+            const content = await this.fileService.readFile(resource);
+            snippets[key] = ( content.value.toString());
+        }
+        return snippets;
+    }
+    async getSnippetsResources(profile, excluded) {
+        const snippets = [];
+        let stat;
+        try {
+            stat = await this.fileService.resolve(profile.snippetsHome);
+        }
+        catch (e) {
+            if (e instanceof FileOperationError && e.fileOperationResult === 1 ) {
+                return snippets;
+            }
+            else {
+                throw e;
+            }
+        }
+        for (const { resource } of stat.children || []) {
+            if (excluded?.has(resource)) {
+                continue;
+            }
+            const extension = this.uriIdentityService.extUri.extname(resource);
+            if (extension === '.json' || extension === '.code-snippets') {
+                snippets.push(resource);
+            }
+        }
+        return snippets;
+    }
+};
+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 = "snippets" ;
+        this.handle = ( this.profile.snippetsHome.toString());
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/snippetsResource',
+            'snippets',
+            "Snippets"
+        )) };
+        this.collapsibleState = TreeItemCollapsibleState.Collapsed;
+        this.excludedSnippets = ( new ResourceSet());
+    }
+    async getChildren() {
+        const snippetsResources = await this.instantiationService.createInstance(SnippetsResource).getSnippetsResources(this.profile);
+        const that = this;
+        return ( snippetsResources.map(resource => ({
+            handle: ( resource.toString()),
+            parent: that,
+            resourceUri: resource,
+            collapsibleState: TreeItemCollapsibleState.None,
+            accessibilityInformation: {
+                label: this.uriIdentityService.extUri.basename(resource),
+            },
+            checkbox: that.checkbox ? {
+                get isChecked() { return !( that.excludedSnippets.has(resource)); },
+                set isChecked(value) {
+                    if (value) {
+                        that.excludedSnippets.delete(resource);
+                    }
+                    else {
+                        that.excludedSnippets.add(resource);
+                    }
+                },
+                accessibilityInformation: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/snippetsResource',
+                        'exclude',
+                        "Select Snippet {0}",
+                        this.uriIdentityService.extUri.basename(resource)
+                    )),
+                }
+            } : undefined,
+            command: {
+                id: API_OPEN_EDITOR_COMMAND_ID,
+                title: '',
+                arguments: [resource, undefined, undefined]
+            }
+        })));
+    }
+    async hasContent() {
+        const snippetsResources = await this.instantiationService.createInstance(SnippetsResource).getSnippetsResources(this.profile);
+        return snippetsResources.length > 0;
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(SnippetsResource).getContent(this.profile, this.excludedSnippets);
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.snippets;
+    }
+};
+SnippetsResourceTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IUriIdentityService))
+], SnippetsResourceTreeItem));
+
+export { SnippetsResource, SnippetsResourceInitializer, SnippetsResourceTreeItem };

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

@@ -0,0 +1,118 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+let TasksResourceInitializer = class TasksResourceInitializer {
+    constructor(userDataProfileService, fileService, logService) {
+        this.userDataProfileService = userDataProfileService;
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async initialize(content) {
+        const tasksContent = JSON.parse(content);
+        if (!tasksContent.tasks) {
+            this.logService.info(`Initializing Profile: No tasks to apply...`);
+            return;
+        }
+        await this.fileService.writeFile(this.userDataProfileService.currentProfile.tasksResource, VSBuffer.fromString(tasksContent.tasks));
+    }
+};
+TasksResourceInitializer = ( __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
+], TasksResourceInitializer));
+let TasksResource = class TasksResource {
+    constructor(fileService, logService) {
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async getContent(profile) {
+        const tasksContent = await this.getTasksResourceContent(profile);
+        return JSON.stringify(tasksContent);
+    }
+    async getTasksResourceContent(profile) {
+        const tasksContent = await this.getTasksContent(profile);
+        return { tasks: tasksContent };
+    }
+    async apply(content, profile) {
+        const tasksContent = JSON.parse(content);
+        if (!tasksContent.tasks) {
+            this.logService.info(`Importing Profile (${profile.name}): No tasks to apply...`);
+            return;
+        }
+        await this.fileService.writeFile(profile.tasksResource, VSBuffer.fromString(tasksContent.tasks));
+    }
+    async getTasksContent(profile) {
+        try {
+            const content = await this.fileService.readFile(profile.tasksResource);
+            return ( content.value.toString());
+        }
+        catch (error) {
+            if (error instanceof FileOperationError && error.fileOperationResult === 1 ) {
+                return null;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+};
+TasksResource = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ILogService))
+], TasksResource));
+let TasksResourceTreeItem = class TasksResourceTreeItem {
+    constructor(profile, uriIdentityService, instantiationService) {
+        this.profile = profile;
+        this.uriIdentityService = uriIdentityService;
+        this.instantiationService = instantiationService;
+        this.type = "tasks" ;
+        this.handle = "tasks" ;
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/tasksResource',
+            'tasks',
+            "User 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]
+                }
+            }];
+    }
+    async hasContent() {
+        const tasksContent = await this.instantiationService.createInstance(TasksResource).getTasksResourceContent(this.profile);
+        return tasksContent.tasks !== null;
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(TasksResource).getContent(this.profile);
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.tasks;
+    }
+};
+TasksResourceTreeItem = ( __decorate([
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, IInstantiationService))
+], TasksResourceTreeItem));
+
+export { TasksResource, TasksResourceInitializer, TasksResourceTreeItem };