@codingame/monaco-vscode-user-data-profile-service-override 5.3.0 → 6.0.1

package/vscode/src/vs/workbench/contrib/userDataProfile/browser/userDataProfilesEditor.js

@@ -0,0 +1,943 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './media/userDataProfilesEditor.css.js';
+import { append, $, Dimension, trackFocus, addDisposableListener, EventType, EventHelper } from 'vscode/vscode/vs/base/browser/dom';
+import { SubmenuAction, Action, Separator } from 'vscode/vscode/vs/base/common/actions';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
+import { ProfileResourceType } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+import { PROFILE_FILTER, defaultUserDataProfileIcon } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IUserDataProfileManagementService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { SplitView, Sizing } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
+import { ButtonWithDropdown, Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { defaultButtonStyles, defaultInputBoxStyles, defaultSelectBoxStyles, defaultCheckboxStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { registerColor } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { PANEL_BORDER } from 'vscode/vscode/vs/workbench/common/theme';
+import { WorkbenchObjectTree, WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { ObjectTreeElementCollapseState } from 'vscode/vscode/vs/base/browser/ui/tree/tree';
+import { DisposableStore, Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { InputBox, MessageType } from 'vscode/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { Checkbox } from 'vscode/vscode/vs/base/browser/ui/toggle/toggle';
+import { DEFAULT_ICON, ICONS } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfileIcons';
+import { WorkbenchIconSelectBox } from 'vscode/vscode/vs/workbench/services/userDataProfile/browser/iconSelectBox';
+import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
+import { KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
+import { WorkbenchHoverDelegate } from 'vscode/vscode/vs/platform/hover/browser/hover';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
+import { HoverPosition } from 'vscode/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { SelectBox } from 'vscode/vscode/vs/base/browser/ui/selectBox/selectBox';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IEditorProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { ExtensionsResourceTreeItem } from '../../../services/userDataProfile/browser/extensionsResource.js';
+import { isString, isUndefined } from 'vscode/vscode/vs/base/common/types';
+import { basename } from 'vscode/vscode/vs/base/common/resources';
+import { RenderIndentGuides } from 'vscode/vscode/vs/base/browser/ui/tree/abstractTree';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ResourceLabels, DEFAULT_LABELS_CONTAINER } from 'vscode/vscode/vs/workbench/browser/labels';
+import { IDialogService, IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { UserDataProfileElement, AbstractUserDataProfileElement, NewProfileElement, UserDataProfilesEditorModel } from './userDataProfilesEditorModel.js';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { WorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
+import { createInstantHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { Orientation } from 'vscode/vscode/vs/base/browser/ui/sash/sash';
+
+var UserDataProfilesEditor_1, NewProfileResourceTreeRenderer_1, ProfileResourceChildTreeItemRenderer_1, UserDataProfilesEditorInput_1;
+const _moduleId = "vs/workbench/contrib/userDataProfile/browser/userDataProfilesEditor";
+const profilesSashBorder = registerColor('profiles.sashBorder', { dark: PANEL_BORDER, light: PANEL_BORDER, hcDark: PANEL_BORDER, hcLight: PANEL_BORDER }, ( localizeWithPath(_moduleId, 0, "The color of the Profiles editor splitview sash border.")));
+let UserDataProfilesEditor = class UserDataProfilesEditor extends EditorPane {
+    static { UserDataProfilesEditor_1 = this; }
+    static { this.ID = 'workbench.editor.userDataProfiles'; }
+    constructor(group, telemetryService, themeService, storageService, userDataProfileManagementService, quickInputService, dialogService, fileDialogService, contextMenuService, instantiationService) {
+        super(UserDataProfilesEditor_1.ID, group, telemetryService, themeService, storageService);
+        this.userDataProfileManagementService = userDataProfileManagementService;
+        this.quickInputService = quickInputService;
+        this.dialogService = dialogService;
+        this.fileDialogService = fileDialogService;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this.templates = [];
+    }
+    layout(dimension, position) {
+        if (this.container && this.splitView) {
+            const height = dimension.height - 20;
+            this.splitView.layout(this.container?.clientWidth, height);
+            this.splitView.el.style.height = `${height}px`;
+        }
+    }
+    createEditor(parent) {
+        this.container = append(parent, $('.profiles-editor'));
+        const sidebarView = append(this.container, $('.sidebar-view'));
+        const sidebarContainer = append(sidebarView, $('.sidebar-container'));
+        const contentsView = append(this.container, $('.contents-view'));
+        const contentsContainer = append(contentsView, $('.contents-container'));
+        this.profileWidget = this._register(this.instantiationService.createInstance(ProfileWidget, contentsContainer));
+        this.splitView = ( (new SplitView(this.container, {
+            orientation: Orientation.HORIZONTAL,
+            proportionalLayout: true
+        })));
+        this.renderSidebar(sidebarContainer);
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: sidebarView,
+            minimumSize: 175,
+            maximumSize: 350,
+            layout: (width, _, height) => {
+                sidebarView.style.width = `${width}px`;
+                if (height && this.profilesTree) {
+                    this.profilesTree.getHTMLElement().style.height = `${height - 38}px`;
+                    this.profilesTree.layout(height - 38, width);
+                }
+            }
+        }, 300, undefined, true);
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: contentsView,
+            minimumSize: 500,
+            maximumSize: Number.POSITIVE_INFINITY,
+            layout: (width, _, height) => {
+                contentsView.style.width = `${width}px`;
+                if (height) {
+                    this.profileWidget?.layout(( (new Dimension(width, height))));
+                }
+            }
+        }, Sizing.Distribute, undefined, true);
+        const borderColor = this.theme.getColor(profilesSashBorder);
+        this.splitView.style({ separatorBorder: borderColor });
+        this.registerListeners();
+        this.userDataProfileManagementService.getBuiltinProfileTemplates().then(templates => {
+            this.templates = templates;
+            this.profileWidget.templates = templates;
+        });
+    }
+    renderSidebar(parent) {
+        this.renderNewProfileButton(append(parent, $('.new-profile-button')));
+        const renderer = this.instantiationService.createInstance(ProfileTreeElementRenderer);
+        const delegate = ( (new ProfileTreeElementDelegate()));
+        this.profilesTree = this._register(this.instantiationService.createInstance((WorkbenchObjectTree), 'ProfilesTree', append(parent, $('.profiles-tree')), delegate, [renderer], {
+            multipleSelectionSupport: false,
+            setRowLineHeight: false,
+            horizontalScrolling: false,
+            accessibilityProvider: {
+                getAriaLabel(extensionFeature) {
+                    return extensionFeature?.name ?? '';
+                },
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(_moduleId, 1, "Profiles"));
+                }
+            },
+            openOnSingleClick: true,
+            enableStickyScroll: false,
+            identityProvider: {
+                getId(e) {
+                    if (e instanceof UserDataProfileElement) {
+                        return e.profile.id;
+                    }
+                    return e.name;
+                }
+            }
+        }));
+    }
+    renderNewProfileButton(parent) {
+        const button = this._register(( (new ButtonWithDropdown(parent, {
+            actions: {
+                getActions: () => {
+                    const actions = [];
+                    if (this.templates.length) {
+                        actions.push(( (new SubmenuAction('from.template', ( localizeWithPath(_moduleId, 2, "From Template")),  (this.templates.map(
+                            template => ( (new Action(`template:${template.url}`, template.name, undefined, true, async () => {
+                                    this.createNewProfile(( (URI.parse(template.url))));
+                                })))
+                        ))))));
+                        actions.push(( (new Separator())));
+                    }
+                    actions.push(( (new Action('importProfile', ( localizeWithPath(_moduleId, 3, "Import Profile...")), undefined, true, () => this.importProfile()))));
+                    return actions;
+                }
+            },
+            addPrimaryActionToDropdown: false,
+            contextMenuProvider: this.contextMenuService,
+            supportIcons: true,
+            ...defaultButtonStyles
+        }))));
+        button.label = `$(add) ${( localizeWithPath(_moduleId, 4, "New Profile"))}`;
+        this._register(button.onDidClick(e => this.createNewProfile()));
+    }
+    registerListeners() {
+        if (this.profilesTree) {
+            this._register(this.profilesTree.onDidChangeSelection(e => {
+                const [element] = e.elements;
+                if (element instanceof AbstractUserDataProfileElement) {
+                    this.profileWidget?.render(element);
+                }
+            }));
+            this._register(this.profilesTree.onContextMenu(e => {
+                if (e.element instanceof AbstractUserDataProfileElement) {
+                    this.contextMenuService.showContextMenu({
+                        getAnchor: () => e.anchor,
+                        getActions: () => e.element instanceof AbstractUserDataProfileElement ? e.element.contextMenuActions.slice(0) : [],
+                        getActionsContext: () => e.element
+                    });
+                }
+            }));
+        }
+    }
+    async importProfile() {
+        const disposables = ( (new DisposableStore()));
+        const quickPick = disposables.add(this.quickInputService.createQuickPick());
+        const updateQuickPickItems = (value) => {
+            const quickPickItems = [];
+            if (value) {
+                quickPickItems.push({ label: quickPick.value, description: ( localizeWithPath(_moduleId, 5, "Import from URL")) });
+            }
+            quickPickItems.push({ label: ( localizeWithPath(_moduleId, 6, "Select File...")) });
+            quickPick.items = quickPickItems;
+        };
+        quickPick.title = ( localizeWithPath(_moduleId, 7, "Import from Profile Template..."));
+        quickPick.placeholder = ( localizeWithPath(_moduleId, 8, "Provide Profile Template URL"));
+        quickPick.ignoreFocusOut = true;
+        disposables.add(quickPick.onDidChangeValue(updateQuickPickItems));
+        updateQuickPickItems();
+        quickPick.matchOnLabel = false;
+        quickPick.matchOnDescription = false;
+        disposables.add(quickPick.onDidAccept(async () => {
+            quickPick.hide();
+            const selectedItem = quickPick.selectedItems[0];
+            if (!selectedItem) {
+                return;
+            }
+            const url = selectedItem.label === quickPick.value ? ( (URI.parse(quickPick.value))) : await this.getProfileUriFromFileSystem();
+            if (url) {
+                this.createNewProfile(url);
+            }
+        }));
+        disposables.add(quickPick.onDidHide(() => disposables.dispose()));
+        quickPick.show();
+    }
+    async createNewProfile(copyFrom) {
+        if (this.model?.profiles.some(p => p instanceof NewProfileElement)) {
+            const result = await this.dialogService.confirm({
+                type: 'info',
+                message: ( localizeWithPath(
+                    _moduleId,
+                    9,
+                    "A new profile is already being created. Do you want to discard it and create a new one?"
+                )),
+                primaryButton: ( localizeWithPath(_moduleId, 10, "Discard & Create")),
+                cancelButton: ( localizeWithPath(_moduleId, 11, "Cancel"))
+            });
+            if (!result.confirmed) {
+                return;
+            }
+            this.model.revert();
+        }
+        this.model?.createNewProfile(copyFrom);
+    }
+    async getProfileUriFromFileSystem() {
+        const profileLocation = await this.fileDialogService.showOpenDialog({
+            canSelectFolders: false,
+            canSelectFiles: true,
+            canSelectMany: false,
+            filters: PROFILE_FILTER,
+            title: ( localizeWithPath(_moduleId, 12, "Select Profile Template File")),
+        });
+        if (!profileLocation) {
+            return null;
+        }
+        return profileLocation[0];
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        this.model = await input.resolve();
+        this.updateProfilesTree();
+        this._register(this.model.onDidChange((element) => {
+            this.updateProfilesTree(element);
+        }));
+    }
+    focus() {
+        super.focus();
+        this.profilesTree?.domFocus();
+    }
+    updateProfilesTree(elementToSelect) {
+        if (!this.model) {
+            return;
+        }
+        const profileElements = ( (this.model.profiles.map(element => ({ element }))));
+        const currentSelection = this.profilesTree?.getSelection()?.[0];
+        this.profilesTree?.setChildren(null, [
+            {
+                element: { name: ( localizeWithPath(_moduleId, 1, "Profiles")) },
+                children: profileElements,
+                collapsible: false,
+                collapsed: ObjectTreeElementCollapseState.Expanded
+            }
+        ]);
+        if (elementToSelect) {
+            this.profilesTree?.setSelection([elementToSelect]);
+        }
+        else if (currentSelection) {
+            if (currentSelection instanceof AbstractUserDataProfileElement) {
+                if (!this.model.profiles.includes(currentSelection)) {
+                    const elementToSelect = this.model.profiles.find(profile => profile.name === currentSelection.name) ?? this.model.profiles[0];
+                    if (elementToSelect) {
+                        this.profilesTree?.setSelection([elementToSelect]);
+                    }
+                }
+            }
+        }
+        else {
+            const elementToSelect = this.model.profiles.find(profile => profile.active) ?? this.model.profiles[0];
+            if (elementToSelect) {
+                this.profilesTree?.setSelection([elementToSelect]);
+            }
+        }
+    }
+};
+UserDataProfilesEditor = UserDataProfilesEditor_1 = ( (__decorate([
+    ( (__param(1, ITelemetryService))),
+    ( (__param(2, IThemeService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IUserDataProfileManagementService))),
+    ( (__param(5, IQuickInputService))),
+    ( (__param(6, IDialogService))),
+    ( (__param(7, IFileDialogService))),
+    ( (__param(8, IContextMenuService))),
+    ( (__param(9, IInstantiationService)))
+], UserDataProfilesEditor)));
+class ProfileTreeElementDelegate {
+    getHeight(element) {
+        return 30;
+    }
+    getTemplateId() { return 'profileTreeElement'; }
+}
+class ProfileTreeElementRenderer {
+    constructor() {
+        this.templateId = 'profileTreeElement';
+    }
+    renderTemplate(container) {
+        container.classList.add('profile-tree-item');
+        const icon = append(container, $('.profile-tree-item-icon'));
+        const label = append(container, $('.profile-tree-item-label'));
+        const description = append(container, $('.profile-tree-item-description'));
+        append(description, $(`span${ThemeIcon.asCSSSelector(Codicon.check)}`));
+        append(description, $('span', undefined, ( localizeWithPath(_moduleId, 13, "Active"))));
+        return { label, icon, description, disposables: ( (new DisposableStore())) };
+    }
+    renderElement({ element }, index, templateData, height) {
+        templateData.disposables.clear();
+        templateData.label.textContent = element.name;
+        if (element.icon) {
+            templateData.icon.className = ThemeIcon.asClassName(ThemeIcon.fromId(element.icon));
+        }
+        else {
+            templateData.icon.className = 'hide';
+        }
+        templateData.description.classList.toggle('hide', !element.active);
+        if (element.onDidChange) {
+            templateData.disposables.add(element.onDidChange(e => {
+                if (e.name) {
+                    templateData.label.textContent = element.name;
+                }
+                if (e.icon) {
+                    if (element.icon) {
+                        templateData.icon.className = ThemeIcon.asClassName(ThemeIcon.fromId(element.icon));
+                    }
+                    else {
+                        templateData.icon.className = 'hide';
+                    }
+                }
+                if (e.active) {
+                    templateData.description.classList.toggle('hide', !element.active);
+                }
+            }));
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+}
+let ProfileWidget = class ProfileWidget extends Disposable {
+    set templates(templates) {
+        this._templates = templates;
+        this.renderSelectBox();
+    }
+    constructor(parent, hoverService, userDataProfilesService, contextViewService, editorProgressService, commandService, instantiationService) {
+        super();
+        this.hoverService = hoverService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.contextViewService = contextViewService;
+        this.editorProgressService = editorProgressService;
+        this.commandService = commandService;
+        this.instantiationService = instantiationService;
+        this.copyFromOptions = [];
+        this._templates = [];
+        this._profileElement = this._register(( (new MutableDisposable())));
+        const header = append(parent, $('.profile-header'));
+        const title = append(header, $('.profile-title'));
+        append(title, $('span', undefined, ( localizeWithPath(_moduleId, 14, "Profile: "))));
+        this.profileTitle = append(title, $('span'));
+        const actionsContainer = append(header, $('.profile-actions-container'));
+        this.buttonContainer = append(actionsContainer, $('.profile-button-container'));
+        this.toolbar = this._register(instantiationService.createInstance(WorkbenchToolBar, actionsContainer, {
+            hoverDelegate: this._register(createInstantHoverDelegate()),
+        }));
+        const body = append(parent, $('.profile-body'));
+        this.nameContainer = append(body, $('.profile-name-container'));
+        this.iconElement = append(this.nameContainer, $(`${ThemeIcon.asCSSSelector(DEFAULT_ICON)}`, { 'tabindex': '0', 'role': 'button', 'aria-label': ( localizeWithPath(_moduleId, 15, "Profile Icon")) }));
+        this.renderIconSelectBox(this.iconElement);
+        this.nameInput = this._register(( (new InputBox(this.nameContainer, undefined, {
+            inputBoxStyles: defaultInputBoxStyles,
+            ariaLabel: ( localizeWithPath(_moduleId, 16, "Profile Name")),
+            placeholder: ( localizeWithPath(_moduleId, 16, "Profile Name")),
+            validationOptions: {
+                validation: (value) => {
+                    if (!value) {
+                        return {
+                            content: ( localizeWithPath(_moduleId, 17, "Profile name is required and must be a non-empty value.")),
+                            type: MessageType.ERROR
+                        };
+                    }
+                    const initialName = this._profileElement.value?.element instanceof UserDataProfileElement ? this._profileElement.value.element.profile.name : undefined;
+                    if (initialName !== value && ( (this.userDataProfilesService.profiles.some(p => p.name === value)))) {
+                        return {
+                            content: ( localizeWithPath(_moduleId, 18, "Profile with name {0} already exists.", value)),
+                            type: MessageType.ERROR
+                        };
+                    }
+                    return null;
+                }
+            }
+        }))));
+        this.nameInput.onDidChange(value => {
+            if (this._profileElement.value && value) {
+                this._profileElement.value.element.name = value;
+            }
+        });
+        const focusTracker = this._register(trackFocus(this.nameInput.inputElement));
+        this._register(focusTracker.onDidBlur(() => {
+            if (this._profileElement.value && !this.nameInput.value) {
+                this.nameInput.value = this._profileElement.value.element.name;
+            }
+        }));
+        this.copyFromContainer = append(body, $('.profile-copy-from-container'));
+        append(this.copyFromContainer, $('.profile-copy-from-label', undefined, ( localizeWithPath(_moduleId, 19, "Copy from:"))));
+        this.copyFromSelectBox = this._register(this.instantiationService.createInstance(SelectBox, [], 0, this.contextViewService, defaultSelectBoxStyles, {
+            useCustomDrawn: true,
+            ariaLabel: ( localizeWithPath(_moduleId, 20, "Copy profile from")),
+        }));
+        this.copyFromSelectBox.render(append(this.copyFromContainer, $('.profile-select-container')));
+        const contentsContainer = append(body, $('.profile-contents-container'));
+        append(contentsContainer, $('.profile-contents-label', undefined, ( localizeWithPath(_moduleId, 21, "Contents"))));
+        const delegate = ( (new ProfileResourceTreeElementDelegate()));
+        this.resourcesTree = this._register(this.instantiationService.createInstance((WorkbenchAsyncDataTree), 'ProfileEditor-ResourcesTree', append(body, $('.profile-content-tree.file-icon-themable-tree.show-file-icons')), delegate, [
+            this.instantiationService.createInstance(ExistingProfileResourceTreeRenderer),
+            this.instantiationService.createInstance(NewProfileResourceTreeRenderer),
+            this.instantiationService.createInstance(ProfileResourceChildTreeItemRenderer),
+        ], this.instantiationService.createInstance(ProfileResourceTreeDataSource), {
+            multipleSelectionSupport: false,
+            horizontalScrolling: false,
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    if (isString(element?.element)) {
+                        return element.element;
+                    }
+                    if (element?.element) {
+                        return element.element.label?.label ?? '';
+                    }
+                    return '';
+                },
+                getWidgetAriaLabel() {
+                    return '';
+                },
+            },
+            identityProvider: {
+                getId(element) {
+                    if (isString(element?.element)) {
+                        return element.element;
+                    }
+                    if (element?.element) {
+                        return element.element.handle;
+                    }
+                    return '';
+                }
+            },
+            expandOnlyOnTwistieClick: true,
+            renderIndentGuides: RenderIndentGuides.None,
+            openOnSingleClick: true,
+            enableStickyScroll: false,
+        }));
+        this._register(this.resourcesTree.onDidOpen(async (e) => {
+            if (!e.browserEvent) {
+                return;
+            }
+            if (e.browserEvent.target && e.browserEvent.target.classList.contains(Checkbox.CLASS_NAME)) {
+                return;
+            }
+            if (e.element && !isString(e.element.element)) {
+                if (e.element.element.resourceUri) {
+                    await this.commandService.executeCommand(API_OPEN_EDITOR_COMMAND_ID, e.element.element.resourceUri, [SIDE_GROUP], undefined, e);
+                }
+                else if (e.element.element.parent instanceof ExtensionsResourceTreeItem) {
+                    await this.commandService.executeCommand('extension.open', e.element.element.handle, undefined, true, undefined, true);
+                }
+            }
+        }));
+    }
+    renderIconSelectBox(iconContainer) {
+        const iconSelectBox = this._register(this.instantiationService.createInstance(WorkbenchIconSelectBox, { icons: ICONS, inputBoxStyles: defaultInputBoxStyles }));
+        let hoverWidget;
+        const showIconSelectBox = () => {
+            if (this._profileElement.value?.element instanceof UserDataProfileElement && this._profileElement.value.element.profile.isDefault) {
+                return;
+            }
+            iconSelectBox.clearInput();
+            hoverWidget = this.hoverService.showHover({
+                content: iconSelectBox.domNode,
+                target: iconContainer,
+                position: {
+                    hoverPosition: HoverPosition.BELOW,
+                },
+                persistence: {
+                    sticky: true,
+                },
+                appearance: {
+                    showPointer: true,
+                },
+            }, true);
+            if (hoverWidget) {
+                iconSelectBox.layout(( (new Dimension(486, 260))));
+                iconSelectBox.focus();
+            }
+        };
+        this._register(addDisposableListener(iconContainer, EventType.CLICK, (e) => {
+            EventHelper.stop(e, true);
+            showIconSelectBox();
+        }));
+        this._register(addDisposableListener(iconContainer, EventType.KEY_DOWN, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(event, true);
+                showIconSelectBox();
+            }
+        }));
+        this._register(addDisposableListener(iconSelectBox.domNode, EventType.KEY_DOWN, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            if (event.equals(KeyCode.Escape)) {
+                EventHelper.stop(event, true);
+                hoverWidget?.dispose();
+                iconContainer.focus();
+            }
+        }));
+        this._register(iconSelectBox.onDidSelect(selectedIcon => {
+            hoverWidget?.dispose();
+            iconContainer.focus();
+            if (this._profileElement.value) {
+                this._profileElement.value.element.icon = selectedIcon.id;
+            }
+        }));
+    }
+    renderSelectBox() {
+        const separator = { text: '\u2500\u2500\u2500\u2500\u2500\u2500', isDisabled: true };
+        this.copyFromOptions.push({ text: ( localizeWithPath(_moduleId, 22, "None")) });
+        if (this._templates.length) {
+            this.copyFromOptions.push({ ...separator, decoratorRight: ( localizeWithPath(_moduleId, 23, "Profile Templates")) });
+            for (const template of this._templates) {
+                this.copyFromOptions.push({ text: template.name, id: template.url, source: ( (URI.parse(template.url))) });
+            }
+        }
+        this.copyFromOptions.push({ ...separator, decoratorRight: ( localizeWithPath(_moduleId, 24, "Existing Profiles")) });
+        for (const profile of this.userDataProfilesService.profiles) {
+            this.copyFromOptions.push({ text: profile.name, id: profile.id, source: profile });
+        }
+        this.copyFromSelectBox.setOptions(this.copyFromOptions);
+        this._register(this.copyFromSelectBox.onDidSelect(option => {
+            if (this._profileElement.value?.element instanceof NewProfileElement) {
+                this._profileElement.value.element.copyFrom = this.copyFromOptions[option.index].source;
+            }
+        }));
+    }
+    layout(dimension) {
+        this.resourcesTree.layout(dimension.height - 34 - 20 - 25 - 20, dimension.width);
+    }
+    render(profileElement) {
+        const disposables = ( (new DisposableStore()));
+        this._profileElement.value = { element: profileElement, dispose: () => disposables.dispose() };
+        this.renderProfileElement(profileElement);
+        disposables.add(profileElement.onDidChange(e => this.renderProfileElement(profileElement)));
+        const profile = profileElement instanceof UserDataProfileElement ? profileElement.profile : undefined;
+        this.nameInput.setEnabled(!profile?.isDefault);
+        this.resourcesTree.setInput(profileElement);
+        disposables.add(profileElement.onDidChange(e => {
+            if (e.flags || e.copyFrom) {
+                const viewState = this.resourcesTree.getViewState();
+                this.resourcesTree.setInput(profileElement, {
+                    ...viewState,
+                    expanded: viewState.expanded?.map(e => e)
+                });
+            }
+        }));
+        if (profileElement.primaryAction) {
+            this.buttonContainer.classList.remove('hide');
+            const button = disposables.add(( (new Button(this.buttonContainer, {
+                supportIcons: true,
+                ...defaultButtonStyles
+            }))));
+            button.label = profileElement.primaryAction.label;
+            button.enabled = profileElement.primaryAction.enabled;
+            disposables.add(button.onDidClick(() => this.editorProgressService.showWhile(profileElement.primaryAction.run())));
+            disposables.add(profileElement.primaryAction.onDidChange((e) => {
+                if (!isUndefined(e.enabled)) {
+                    button.enabled = profileElement.primaryAction.enabled;
+                }
+            }));
+            disposables.add(profileElement.onDidChange(e => {
+                if (e.message) {
+                    button.setTitle(profileElement.message ?? profileElement.primaryAction.label);
+                    button.element.classList.toggle('error', !!profileElement.message);
+                }
+            }));
+        }
+        else {
+            this.buttonContainer.classList.add('hide');
+        }
+        this.toolbar.setActions(profileElement.titleActions[0].slice(0), profileElement.titleActions[1].slice(0));
+        this.nameInput.focus();
+        if (profileElement instanceof NewProfileElement) {
+            this.nameInput.select();
+        }
+    }
+    renderProfileElement(profileElement) {
+        this.profileTitle.textContent = profileElement.name;
+        this.nameInput.value = profileElement.name;
+        if (profileElement.icon) {
+            this.iconElement.className = ThemeIcon.asClassName(ThemeIcon.fromId(profileElement.icon));
+        }
+        else {
+            this.iconElement.className = ThemeIcon.asClassName(ThemeIcon.fromId(DEFAULT_ICON.id));
+        }
+        if (profileElement instanceof NewProfileElement) {
+            this.copyFromContainer.classList.remove('hide');
+            const id = profileElement.copyFrom instanceof URI ? ( (profileElement.copyFrom.toString())) : profileElement.copyFrom?.id;
+            const index = id
+                ? this.copyFromOptions.findIndex(option => option.id === id)
+                : 0;
+            if (index !== -1) {
+                this.copyFromSelectBox.setOptions(this.copyFromOptions);
+                this.copyFromSelectBox.setEnabled(true);
+                this.copyFromSelectBox.select(index);
+            }
+            else {
+                this.copyFromSelectBox.setOptions([{ text: basename(profileElement.copyFrom) }]);
+                this.copyFromSelectBox.setEnabled(false);
+            }
+        }
+        else {
+            this.copyFromContainer.classList.add('hide');
+        }
+    }
+};
+ProfileWidget = ( (__decorate([
+    ( (__param(1, IHoverService))),
+    ( (__param(2, IUserDataProfilesService))),
+    ( (__param(3, IContextViewService))),
+    ( (__param(4, IEditorProgressService))),
+    ( (__param(5, ICommandService))),
+    ( (__param(6, IInstantiationService)))
+], ProfileWidget)));
+class ProfileResourceTreeElementDelegate {
+    getTemplateId(element) {
+        if (!isString(element.element)) {
+            return ProfileResourceChildTreeItemRenderer.TEMPLATE_ID;
+        }
+        if (element.root instanceof NewProfileElement) {
+            return NewProfileResourceTreeRenderer.TEMPLATE_ID;
+        }
+        return ExistingProfileResourceTreeRenderer.TEMPLATE_ID;
+    }
+    getHeight(element) {
+        return 30;
+    }
+}
+let ProfileResourceTreeDataSource = class ProfileResourceTreeDataSource {
+    constructor(editorProgressService) {
+        this.editorProgressService = editorProgressService;
+    }
+    hasChildren(element) {
+        if (element instanceof AbstractUserDataProfileElement) {
+            return true;
+        }
+        if (isString(element.element)) {
+            if (element.root.getFlag(element.element)) {
+                return false;
+            }
+            if (element.root instanceof NewProfileElement) {
+                return element.root.copyFrom !== undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+    async getChildren(element) {
+        if (element instanceof AbstractUserDataProfileElement) {
+            const resourceTypes = [
+                ProfileResourceType.Settings,
+                ProfileResourceType.Keybindings,
+                ProfileResourceType.Snippets,
+                ProfileResourceType.Tasks,
+                ProfileResourceType.Extensions
+            ];
+            return (
+                 (resourceTypes.map(resourceType => ({ element: resourceType, root: element })))
+            );
+        }
+        if (isString(element.element)) {
+            const progressRunner = this.editorProgressService.show(true);
+            try {
+                const extensions = await element.root.getChildren(element.element);
+                return (
+                     (extensions.map(extension => ({ element: extension, root: element.root })))
+                );
+            }
+            finally {
+                progressRunner.done();
+            }
+        }
+        return [];
+    }
+};
+ProfileResourceTreeDataSource = ( (__decorate([
+    ( (__param(0, IEditorProgressService)))
+], ProfileResourceTreeDataSource)));
+class AbstractProfileResourceTreeRenderer extends Disposable {
+    getResourceTypeTitle(resourceType) {
+        switch (resourceType) {
+            case ProfileResourceType.Settings:
+                return ( localizeWithPath(_moduleId, 25, "Settings"));
+            case ProfileResourceType.Keybindings:
+                return ( localizeWithPath(_moduleId, 26, "Keyboard Shortcuts"));
+            case ProfileResourceType.Snippets:
+                return ( localizeWithPath(_moduleId, 27, "User Snippets"));
+            case ProfileResourceType.Tasks:
+                return ( localizeWithPath(_moduleId, 28, "User Tasks"));
+            case ProfileResourceType.Extensions:
+                return ( localizeWithPath(_moduleId, 29, "Extensions"));
+        }
+        return '';
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+}
+class ExistingProfileResourceTreeRenderer extends AbstractProfileResourceTreeRenderer {
+    constructor() {
+        super(...arguments);
+        this.templateId = ExistingProfileResourceTreeRenderer.TEMPLATE_ID;
+    }
+    static { this.TEMPLATE_ID = 'ExistingProfileResourceTemplate'; }
+    renderTemplate(parent) {
+        const disposables = ( (new DisposableStore()));
+        const container = append(parent, $('.profile-tree-item-container.existing-profile-resource-type-container'));
+        const checkbox = disposables.add(( (new Checkbox('', false, defaultCheckboxStyles))));
+        append(container, checkbox.domNode);
+        const label = append(container, $('.profile-resource-type-label'));
+        const description = append(container, $('.profile-resource-type-description', undefined, ( localizeWithPath(_moduleId, 30, "Using Default Profile"))));
+        return { checkbox, label, description, disposables, elementDisposables: disposables.add(( (new DisposableStore()))) };
+    }
+    renderElement({ element: profileResourceTreeElement }, index, templateData, height) {
+        templateData.elementDisposables.clear();
+        const { element, root } = profileResourceTreeElement;
+        if (!(root instanceof UserDataProfileElement)) {
+            throw ( (new Error(
+                'ExistingProfileResourceTreeRenderer can only render existing profile element'
+            )));
+        }
+        if (!isString(element)) {
+            throw ( (new Error(
+                'ExistingProfileResourceTreeRenderer can only render profile resource types'
+            )));
+        }
+        templateData.label.textContent = this.getResourceTypeTitle(element);
+        if (root instanceof UserDataProfileElement && root.profile.isDefault) {
+            templateData.checkbox.checked = true;
+            templateData.checkbox.disable();
+            templateData.description.classList.add('hide');
+        }
+        else {
+            templateData.checkbox.enable();
+            const checked = !root.getFlag(element);
+            templateData.checkbox.checked = checked;
+            templateData.description.classList.toggle('hide', checked);
+            templateData.elementDisposables.add(templateData.checkbox.onChange(() => root.setFlag(element, !templateData.checkbox.checked)));
+            templateData.elementDisposables.add(root.onDidChange(e => {
+                if (e.flags) {
+                    templateData.description.classList.toggle('hide', !root.getFlag(element));
+                }
+            }));
+        }
+    }
+}
+let NewProfileResourceTreeRenderer = class NewProfileResourceTreeRenderer extends AbstractProfileResourceTreeRenderer {
+    static { NewProfileResourceTreeRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'NewProfileResourceTemplate'; }
+    constructor(contextViewService, instantiationService) {
+        super();
+        this.contextViewService = contextViewService;
+        this.instantiationService = instantiationService;
+        this.templateId = NewProfileResourceTreeRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(parent) {
+        const disposables = ( (new DisposableStore()));
+        const container = append(parent, $('.profile-tree-item-container.new-profile-resource-type-container'));
+        const labelContainer = append(container, $('.profile-resource-type-label-container'));
+        const label = append(labelContainer, $('span.profile-resource-type-label'));
+        const selectBox = this._register(this.instantiationService.createInstance(SelectBox, [
+            { text: ( localizeWithPath(_moduleId, 31, "Empty")) },
+            { text: ( localizeWithPath(_moduleId, 32, "Copy")) },
+            { text: ( localizeWithPath(_moduleId, 33, "Use Default Profile")) }
+        ], 0, this.contextViewService, defaultSelectBoxStyles, {
+            useCustomDrawn: true,
+        }));
+        const selectContainer = append(container, $('.profile-select-container'));
+        selectBox.render(selectContainer);
+        return { label, selectContainer, selectBox, disposables, elementDisposables: disposables.add(( (new DisposableStore()))) };
+    }
+    renderElement({ element: profileResourceTreeElement }, index, templateData, height) {
+        templateData.elementDisposables.clear();
+        const { element, root } = profileResourceTreeElement;
+        if (!(root instanceof NewProfileElement)) {
+            throw ( (new Error('NewProfileResourceTreeRenderer can only render new profile element')));
+        }
+        if (!isString(element)) {
+            throw ( (new Error('NewProfileResourceTreeRenderer can only profile resoyrce types')));
+        }
+        templateData.label.textContent = this.getResourceTypeTitle(element);
+        templateData.selectBox.select(root.getCopyFlag(element) ? 1 : root.getFlag(element) ? 2 : 0);
+        templateData.elementDisposables.add(templateData.selectBox.onDidSelect(option => {
+            root.setFlag(element, option.index === 2);
+            root.setCopyFlag(element, option.index === 1);
+        }));
+    }
+};
+NewProfileResourceTreeRenderer = NewProfileResourceTreeRenderer_1 = ( (__decorate([
+    ( (__param(0, IContextViewService))),
+    ( (__param(1, IInstantiationService)))
+], NewProfileResourceTreeRenderer)));
+let ProfileResourceChildTreeItemRenderer = class ProfileResourceChildTreeItemRenderer extends AbstractProfileResourceTreeRenderer {
+    static { ProfileResourceChildTreeItemRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'ProfileResourceChildTreeItemTemplate'; }
+    constructor(instantiationService) {
+        super();
+        this.templateId = ProfileResourceChildTreeItemRenderer_1.TEMPLATE_ID;
+        this.labels = instantiationService.createInstance(ResourceLabels, DEFAULT_LABELS_CONTAINER);
+        this.hoverDelegate = this._register(instantiationService.createInstance(WorkbenchHoverDelegate, 'mouse', false, {}));
+    }
+    renderTemplate(parent) {
+        const disposables = ( (new DisposableStore()));
+        const container = append(parent, $('.profile-tree-item-container.profile-resource-child-container'));
+        const checkbox = disposables.add(( (new Checkbox('', false, defaultCheckboxStyles))));
+        append(container, checkbox.domNode);
+        const resourceLabel = disposables.add(this.labels.create(container, { hoverDelegate: this.hoverDelegate }));
+        return { checkbox, resourceLabel, disposables, elementDisposables: disposables.add(( (new DisposableStore()))) };
+    }
+    renderElement({ element: profileResourceTreeElement }, index, templateData, height) {
+        templateData.elementDisposables.clear();
+        const { element } = profileResourceTreeElement;
+        if (isString(element)) {
+            throw ( (new Error(
+                'NewProfileResourceTreeRenderer can only render profile resource child tree items'
+            )));
+        }
+        if (element.checkbox) {
+            templateData.checkbox.domNode.classList.remove('hide');
+            templateData.checkbox.checked = element.checkbox.isChecked;
+            templateData.checkbox.domNode.ariaLabel = element.checkbox.accessibilityInformation?.label ?? '';
+            if (element.checkbox.accessibilityInformation?.role) {
+                templateData.checkbox.domNode.role = element.checkbox.accessibilityInformation.role;
+            }
+        }
+        else {
+            templateData.checkbox.domNode.classList.add('hide');
+        }
+        const resource = URI.revive(element.resourceUri);
+        templateData.resourceLabel.setResource({
+            name: resource ? basename(resource) : element.label?.label,
+            description: isString(element.description) ? element.description : undefined,
+            resource
+        }, {
+            forceLabel: true,
+            hideIcon: !resource,
+        });
+    }
+};
+ProfileResourceChildTreeItemRenderer = ProfileResourceChildTreeItemRenderer_1 = ( (__decorate([
+    ( (__param(0, IInstantiationService)))
+], ProfileResourceChildTreeItemRenderer)));
+let UserDataProfilesEditorInput = class UserDataProfilesEditorInput extends EditorInput {
+    static { UserDataProfilesEditorInput_1 = this; }
+    static { this.ID = 'workbench.input.userDataProfiles'; }
+    get dirty() { return this._dirty; }
+    set dirty(dirty) {
+        if (this._dirty !== dirty) {
+            this._dirty = dirty;
+            this._onDidChangeDirty.fire();
+        }
+    }
+    constructor(instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.resource = undefined;
+        this._dirty = false;
+        this.model = UserDataProfilesEditorModel.getInstance(this.instantiationService);
+        this._register(this.model.onDidChange(e => this.dirty = ( (this.model.profiles.some(profile => profile instanceof NewProfileElement)))));
+    }
+    get typeId() { return UserDataProfilesEditorInput_1.ID; }
+    getName() { return ( localizeWithPath(_moduleId, 34, "Profiles")); }
+    getIcon() { return defaultUserDataProfileIcon; }
+    async resolve() {
+        return this.model;
+    }
+    isDirty() {
+        return this.dirty;
+    }
+    async save() {
+        await this.model.saveNewProfile();
+        return this;
+    }
+    async revert() {
+        this.model.revert();
+    }
+    matches(otherInput) { return otherInput instanceof UserDataProfilesEditorInput_1; }
+};
+UserDataProfilesEditorInput = UserDataProfilesEditorInput_1 = ( (__decorate([
+    ( (__param(0, IInstantiationService)))
+], UserDataProfilesEditorInput)));
+class UserDataProfilesEditorInputSerializer {
+    canSerialize(editorInput) { return true; }
+    serialize(editorInput) { return ''; }
+    deserialize(instantiationService) { return instantiationService.createInstance(UserDataProfilesEditorInput); }
+}
+
+export { UserDataProfilesEditor, UserDataProfilesEditorInput, UserDataProfilesEditorInputSerializer, profilesSashBorder };