@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsViewer.js

@@ -0,0 +1,285 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { dispose, Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchAsyncDataTree, IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Renderer } from './extensionsList.js';
+import { listFocusBackground, listFocusForeground, foreground, editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { getAriaLabelForExtension } from './extensionsViews.js';
+
+var ExtensionRenderer_1;
+let ExtensionsGridView = class ExtensionsGridView extends Disposable {
+    constructor(parent, delegate, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.element = dom.append(parent, dom.$('.extensions-grid-view'));
+        this.renderer = this.instantiationService.createInstance(Renderer, { onFocus: Event.None, onBlur: Event.None }, { hoverOptions: { position() { return 2 ; } } });
+        this.delegate = delegate;
+        this.disposableStore = this._register(( new DisposableStore()));
+    }
+    setExtensions(extensions) {
+        this.disposableStore.clear();
+        extensions.forEach((e, index) => this.renderExtension(e, index));
+    }
+    renderExtension(extension, index) {
+        const extensionContainer = dom.append(this.element, dom.$('.extension-container'));
+        extensionContainer.style.height = `${this.delegate.getHeight()}px`;
+        extensionContainer.setAttribute('tabindex', '0');
+        const template = this.renderer.renderTemplate(extensionContainer);
+        this.disposableStore.add(toDisposable(() => this.renderer.disposeTemplate(template)));
+        const openExtensionAction = this.instantiationService.createInstance(OpenExtensionAction);
+        openExtensionAction.extension = extension;
+        template.name.setAttribute('tabindex', '0');
+        const handleEvent = (e) => {
+            if (e instanceof StandardKeyboardEvent && e.keyCode !== 3 ) {
+                return;
+            }
+            openExtensionAction.run(e.ctrlKey || e.metaKey);
+            e.stopPropagation();
+            e.preventDefault();
+        };
+        this.disposableStore.add(dom.addDisposableListener(template.name, dom.EventType.CLICK, (e) => handleEvent(( new StandardMouseEvent(e)))));
+        this.disposableStore.add(dom.addDisposableListener(template.name, dom.EventType.KEY_DOWN, (e) => handleEvent(( new StandardKeyboardEvent(e)))));
+        this.disposableStore.add(dom.addDisposableListener(extensionContainer, dom.EventType.KEY_DOWN, (e) => handleEvent(( new StandardKeyboardEvent(e)))));
+        this.renderer.renderElement(extension, index, template);
+    }
+};
+ExtensionsGridView = ( __decorate([
+    ( __param(2, IInstantiationService))
+], ExtensionsGridView));
+class AsyncDataSource {
+    hasChildren({ hasChildren }) {
+        return hasChildren;
+    }
+    getChildren(extensionData) {
+        return extensionData.getChildren();
+    }
+}
+class VirualDelegate {
+    getHeight(element) {
+        return 62;
+    }
+    getTemplateId({ extension }) {
+        return extension ? ExtensionRenderer.TEMPLATE_ID : UnknownExtensionRenderer.TEMPLATE_ID;
+    }
+}
+let ExtensionRenderer = class ExtensionRenderer {
+    static { ExtensionRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'extension-template'; }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+    }
+    get templateId() {
+        return ExtensionRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        container.classList.add('extension');
+        const icon = dom.append(container, dom.$('img.icon'));
+        const details = dom.append(container, dom.$('.details'));
+        const header = dom.append(details, dom.$('.header'));
+        const name = dom.append(header, dom.$('span.name'));
+        const openExtensionAction = this.instantiationService.createInstance(OpenExtensionAction);
+        const extensionDisposables = [dom.addDisposableListener(name, 'click', (e) => {
+                openExtensionAction.run(e.ctrlKey || e.metaKey);
+                e.stopPropagation();
+                e.preventDefault();
+            })];
+        const identifier = dom.append(header, dom.$('span.identifier'));
+        const footer = dom.append(details, dom.$('.footer'));
+        const author = dom.append(footer, dom.$('.author'));
+        return {
+            icon,
+            name,
+            identifier,
+            author,
+            extensionDisposables,
+            set extensionData(extensionData) {
+                openExtensionAction.extension = extensionData.extension;
+            }
+        };
+    }
+    renderElement(node, index, data) {
+        const extension = node.element.extension;
+        data.extensionDisposables.push(dom.addDisposableListener(data.icon, 'error', () => data.icon.src = extension.iconUrlFallback, { once: true }));
+        data.icon.src = extension.iconUrl;
+        if (!data.icon.complete) {
+            data.icon.style.visibility = 'hidden';
+            data.icon.onload = () => data.icon.style.visibility = 'inherit';
+        }
+        else {
+            data.icon.style.visibility = 'inherit';
+        }
+        data.name.textContent = extension.displayName;
+        data.identifier.textContent = extension.identifier.id;
+        data.author.textContent = extension.publisherDisplayName;
+        data.extensionData = node.element;
+    }
+    disposeTemplate(templateData) {
+        templateData.extensionDisposables = dispose(templateData.extensionDisposables);
+    }
+};
+ExtensionRenderer = ExtensionRenderer_1 = ( __decorate([
+    ( __param(0, IInstantiationService))
+], ExtensionRenderer));
+class UnknownExtensionRenderer {
+    static { this.TEMPLATE_ID = 'unknown-extension-template'; }
+    get templateId() {
+        return UnknownExtensionRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const messageContainer = dom.append(container, dom.$('div.unknown-extension'));
+        dom.append(messageContainer, dom.$('span.error-marker')).textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsViewer',
+            'error',
+            "Error"
+        ));
+        dom.append(messageContainer, dom.$('span.message')).textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsViewer',
+            'Unknown Extension',
+            "Unknown Extension:"
+        ));
+        const identifier = dom.append(messageContainer, dom.$('span.message'));
+        return { identifier };
+    }
+    renderElement(node, index, data) {
+        data.identifier.textContent = node.element.extension.identifier.id;
+    }
+    disposeTemplate(data) {
+    }
+}
+let OpenExtensionAction = class OpenExtensionAction extends Action {
+    constructor(extensionsWorkdbenchService) {
+        super('extensions.action.openExtension', '');
+        this.extensionsWorkdbenchService = extensionsWorkdbenchService;
+    }
+    set extension(extension) {
+        this._extension = extension;
+    }
+    run(sideByside) {
+        if (this._extension) {
+            return this.extensionsWorkdbenchService.open(this._extension, { sideByside });
+        }
+        return Promise.resolve();
+    }
+};
+OpenExtensionAction = ( __decorate([
+    ( __param(0, IExtensionsWorkbenchService))
+], OpenExtensionAction));
+let ExtensionsTree = class ExtensionsTree extends WorkbenchAsyncDataTree {
+    constructor(input, container, overrideStyles, contextKeyService, listService, instantiationService, configurationService, extensionsWorkdbenchService) {
+        const delegate = ( new VirualDelegate());
+        const dataSource = ( new AsyncDataSource());
+        const renderers = [instantiationService.createInstance(ExtensionRenderer), instantiationService.createInstance(UnknownExtensionRenderer)];
+        const identityProvider = {
+            getId({ extension, parent }) {
+                return parent ? this.getId(parent) + '/' + extension.identifier.id : extension.identifier.id;
+            }
+        };
+        super('ExtensionsTree', container, delegate, renderers, dataSource, {
+            indent: 40,
+            identityProvider,
+            multipleSelectionSupport: false,
+            overrideStyles,
+            accessibilityProvider: {
+                getAriaLabel(extensionData) {
+                    return getAriaLabelForExtension(extensionData.extension);
+                },
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsViewer',
+                        'extensions',
+                        "Extensions"
+                    ));
+                }
+            }
+        }, instantiationService, contextKeyService, listService, configurationService);
+        this.setInput(input);
+        this.disposables.add(this.onDidChangeSelection(event => {
+            if (event.browserEvent && event.browserEvent instanceof KeyboardEvent) {
+                extensionsWorkdbenchService.open(event.elements[0].extension, { sideByside: false });
+            }
+        }));
+    }
+};
+ExtensionsTree = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IListService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IExtensionsWorkbenchService))
+], ExtensionsTree));
+class ExtensionData {
+    constructor(extension, parent, getChildrenExtensionIds, extensionsWorkbenchService) {
+        this.extension = extension;
+        this.parent = parent;
+        this.getChildrenExtensionIds = getChildrenExtensionIds;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.childrenExtensionIds = this.getChildrenExtensionIds(extension);
+    }
+    get hasChildren() {
+        return isNonEmptyArray(this.childrenExtensionIds);
+    }
+    async getChildren() {
+        if (this.hasChildren) {
+            const result = await getExtensions(this.childrenExtensionIds, this.extensionsWorkbenchService);
+            return ( result.map(extension => ( new ExtensionData(
+                extension,
+                this,
+                this.getChildrenExtensionIds,
+                this.extensionsWorkbenchService
+            ))));
+        }
+        return null;
+    }
+}
+async function getExtensions(extensions, extensionsWorkbenchService) {
+    const localById = extensionsWorkbenchService.local.reduce((result, e) => { result.set(e.identifier.id.toLowerCase(), e); return result; }, ( new Map()));
+    const result = [];
+    const toQuery = [];
+    for (const extensionId of extensions) {
+        const id = extensionId.toLowerCase();
+        const local = localById.get(id);
+        if (local) {
+            result.push(local);
+        }
+        else {
+            toQuery.push(id);
+        }
+    }
+    if (toQuery.length) {
+        const galleryResult = await extensionsWorkbenchService.getExtensions(( toQuery.map(id => ({ id }))), CancellationToken.None);
+        result.push(...galleryResult);
+    }
+    return result;
+}
+registerThemingParticipant((theme, collector) => {
+    const focusBackground = theme.getColor(listFocusBackground);
+    if (focusBackground) {
+        collector.addRule(`.extensions-grid-view .extension-container:focus { background-color: ${focusBackground}; outline: none; }`);
+    }
+    const focusForeground = theme.getColor(listFocusForeground);
+    if (focusForeground) {
+        collector.addRule(`.extensions-grid-view .extension-container:focus { color: ${focusForeground}; }`);
+    }
+    const foregroundColor = theme.getColor(foreground);
+    const editorBackgroundColor = theme.getColor(editorBackground);
+    if (foregroundColor && editorBackgroundColor) {
+        const authorForeground = ( foregroundColor.transparent(.9)).makeOpaque(editorBackgroundColor);
+        collector.addRule(`.extensions-grid-view .extension-container:not(.disabled) .author { color: ${authorForeground}; }`);
+        const disabledExtensionForeground = ( foregroundColor.transparent(.5)).makeOpaque(editorBackgroundColor);
+        collector.addRule(`.extensions-grid-view .extension-container.disabled { color: ${disabledExtensionForeground}; }`);
+    }
+});
+
+export { ExtensionData, ExtensionsGridView, ExtensionsTree, getExtensions };