@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/browser/labels.js

@@ -0,0 +1,426 @@
+import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isEqual, basenameOrAuthority, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITextFileService } from '../services/textfile/common/textfiles.js';
+import { IDecorationsService } from '../services/decorations/common/decorations.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { FILES_ASSOCIATIONS_CONFIG, FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { Disposable, dispose, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
+function toResource(props) {
+    if (!props || !props.resource) {
+        return undefined;
+    }
+    if (URI.isUri(props.resource)) {
+        return props.resource;
+    }
+    return props.resource.primary;
+}
+let ResourceLabels = class ResourceLabels extends Disposable {
+    constructor(container, instantiationService, configurationService, modelService, workspaceService, languageService, decorationsService, themeService, labelService, textFileService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        this.workspaceService = workspaceService;
+        this.languageService = languageService;
+        this.decorationsService = decorationsService;
+        this.themeService = themeService;
+        this.labelService = labelService;
+        this.textFileService = textFileService;
+        this._onDidChangeDecorations = this._register(( new Emitter()));
+        this.onDidChangeDecorations = this._onDidChangeDecorations.event;
+        this.widgets = [];
+        this.labels = [];
+        this.registerListeners(container);
+    }
+    registerListeners(container) {
+        this._register(container.onDidChangeVisibility(visible => {
+            this.widgets.forEach(widget => widget.notifyVisibilityChanged(visible));
+        }));
+        this._register(this.languageService.onDidChange(() => this.widgets.forEach(widget => widget.notifyExtensionsRegistered())));
+        this._register(this.modelService.onModelLanguageChanged(e => {
+            if (!e.model.uri) {
+                return;
+            }
+            this.widgets.forEach(widget => widget.notifyModelLanguageChanged(e.model));
+        }));
+        this._register(this.modelService.onModelAdded(model => {
+            if (!model.uri) {
+                return;
+            }
+            this.widgets.forEach(widget => widget.notifyModelAdded(model));
+        }));
+        this._register(this.workspaceService.onDidChangeWorkspaceFolders(() => {
+            this.widgets.forEach(widget => widget.notifyWorkspaceFoldersChange());
+        }));
+        this._register(this.decorationsService.onDidChangeDecorations(e => {
+            let notifyDidChangeDecorations = false;
+            this.widgets.forEach(widget => {
+                if (widget.notifyFileDecorationsChanges(e)) {
+                    notifyDidChangeDecorations = true;
+                }
+            });
+            if (notifyDidChangeDecorations) {
+                this._onDidChangeDecorations.fire();
+            }
+        }));
+        this._register(this.themeService.onDidColorThemeChange(() => this.widgets.forEach(widget => widget.notifyThemeChange())));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(FILES_ASSOCIATIONS_CONFIG)) {
+                this.widgets.forEach(widget => widget.notifyFileAssociationsChange());
+            }
+        }));
+        this._register(this.labelService.onDidChangeFormatters(e => {
+            this.widgets.forEach(widget => widget.notifyFormattersChange(e.scheme));
+        }));
+        this._register(this.textFileService.untitled.onDidChangeLabel(model => {
+            this.widgets.forEach(widget => widget.notifyUntitledLabelChange(model.resource));
+        }));
+    }
+    get(index) {
+        return this.labels[index];
+    }
+    create(container, options) {
+        const widget = this.instantiationService.createInstance(ResourceLabelWidget, container, options);
+        const label = {
+            element: widget.element,
+            onDidRender: widget.onDidRender,
+            setLabel: (label, description, options) => widget.setLabel(label, description, options),
+            setResource: (label, options) => widget.setResource(label, options),
+            setFile: (resource, options) => widget.setFile(resource, options),
+            clear: () => widget.clear(),
+            dispose: () => this.disposeWidget(widget)
+        };
+        this.labels.push(label);
+        this.widgets.push(widget);
+        return label;
+    }
+    disposeWidget(widget) {
+        const index = this.widgets.indexOf(widget);
+        if (index > -1) {
+            this.widgets.splice(index, 1);
+            this.labels.splice(index, 1);
+        }
+        dispose(widget);
+    }
+    clear() {
+        this.widgets = dispose(this.widgets);
+        this.labels = [];
+    }
+    dispose() {
+        super.dispose();
+        this.clear();
+    }
+};
+ResourceLabels = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, ILanguageService)),
+    ( __param(6, IDecorationsService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, ILabelService)),
+    ( __param(9, ITextFileService))
+], ResourceLabels));
+var Redraw;
+( (function(Redraw) {
+    Redraw[Redraw["Basic"] = 1] = "Basic";
+    Redraw[Redraw["Full"] = 2] = "Full";
+})(Redraw || (Redraw = {})));
+let ResourceLabelWidget = class ResourceLabelWidget extends IconLabel {
+    constructor(container, options, languageService, modelService, decorationsService, labelService, textFileService, contextService) {
+        super(container, options);
+        this.languageService = languageService;
+        this.modelService = modelService;
+        this.decorationsService = decorationsService;
+        this.labelService = labelService;
+        this.textFileService = textFileService;
+        this.contextService = contextService;
+        this._onDidRender = this._register(( new Emitter()));
+        this.onDidRender = this._onDidRender.event;
+        this.label = undefined;
+        this.decoration = this._register(( new MutableDisposable()));
+        this.options = undefined;
+        this.computedIconClasses = undefined;
+        this.computedLanguageId = undefined;
+        this.computedPathLabel = undefined;
+        this.computedWorkspaceFolderLabel = undefined;
+        this.needsRedraw = undefined;
+        this.isHidden = false;
+    }
+    notifyVisibilityChanged(visible) {
+        if (visible === this.isHidden) {
+            this.isHidden = !visible;
+            if (visible && this.needsRedraw) {
+                this.render({
+                    updateIcon: this.needsRedraw === Redraw.Full,
+                    updateDecoration: this.needsRedraw === Redraw.Full
+                });
+                this.needsRedraw = undefined;
+            }
+        }
+    }
+    notifyModelLanguageChanged(model) {
+        this.handleModelEvent(model);
+    }
+    notifyModelAdded(model) {
+        this.handleModelEvent(model);
+    }
+    handleModelEvent(model) {
+        const resource = toResource(this.label);
+        if (!resource) {
+            return;
+        }
+        if (isEqual(model.uri, resource)) {
+            if (this.computedLanguageId !== model.getLanguageId()) {
+                this.computedLanguageId = model.getLanguageId();
+                this.render({ updateIcon: true, updateDecoration: false });
+            }
+        }
+    }
+    notifyFileDecorationsChanges(e) {
+        if (!this.options) {
+            return false;
+        }
+        const resource = toResource(this.label);
+        if (!resource) {
+            return false;
+        }
+        if (this.options.fileDecorations && e.affectsResource(resource)) {
+            return this.render({ updateIcon: false, updateDecoration: true });
+        }
+        return false;
+    }
+    notifyExtensionsRegistered() {
+        this.render({ updateIcon: true, updateDecoration: false });
+    }
+    notifyThemeChange() {
+        this.render({ updateIcon: false, updateDecoration: false });
+    }
+    notifyFileAssociationsChange() {
+        this.render({ updateIcon: true, updateDecoration: false });
+    }
+    notifyFormattersChange(scheme) {
+        if (toResource(this.label)?.scheme === scheme) {
+            this.render({ updateIcon: false, updateDecoration: false });
+        }
+    }
+    notifyUntitledLabelChange(resource) {
+        if (isEqual(resource, toResource(this.label))) {
+            this.render({ updateIcon: false, updateDecoration: false });
+        }
+    }
+    notifyWorkspaceFoldersChange() {
+        if (typeof this.computedWorkspaceFolderLabel === 'string') {
+            const resource = toResource(this.label);
+            if (URI.isUri(resource) && this.label?.name === this.computedWorkspaceFolderLabel) {
+                this.setFile(resource, this.options);
+            }
+        }
+    }
+    setFile(resource, options) {
+        const hideLabel = options?.hideLabel;
+        let name;
+        if (!hideLabel) {
+            if (options?.fileKind === FileKind.ROOT_FOLDER) {
+                const workspaceFolder = this.contextService.getWorkspaceFolder(resource);
+                if (workspaceFolder) {
+                    name = workspaceFolder.name;
+                    this.computedWorkspaceFolderLabel = name;
+                }
+            }
+            if (!name) {
+                name = normalizeDriveLetter(basenameOrAuthority(resource));
+            }
+        }
+        let description;
+        if (!options?.hidePath) {
+            description = this.labelService.getUriLabel(dirname(resource), { relative: true });
+        }
+        this.setResource({ resource, name, description }, options);
+    }
+    setResource(label, options = Object.create(null)) {
+        const resource = toResource(label);
+        const isSideBySideEditor = label?.resource && !URI.isUri(label.resource);
+        if (!options.forceLabel && !isSideBySideEditor && resource?.scheme === Schemas.untitled) {
+            const untitledModel = this.textFileService.untitled.get(resource);
+            if (untitledModel && !untitledModel.hasAssociatedFilePath) {
+                if (typeof label.name === 'string') {
+                    label.name = untitledModel.name;
+                }
+                if (typeof label.description === 'string') {
+                    const untitledDescription = untitledModel.resource.path;
+                    if (label.name !== untitledDescription) {
+                        label.description = untitledDescription;
+                    }
+                    else {
+                        label.description = undefined;
+                    }
+                }
+                const untitledTitle = untitledModel.resource.path;
+                if (untitledModel.name !== untitledTitle) {
+                    options.title = `${untitledModel.name} • ${untitledTitle}`;
+                }
+                else {
+                    options.title = untitledTitle;
+                }
+            }
+        }
+        const hasResourceChanged = this.hasResourceChanged(label);
+        const hasPathLabelChanged = hasResourceChanged || this.hasPathLabelChanged(label);
+        const hasFileKindChanged = this.hasFileKindChanged(options);
+        this.label = label;
+        this.options = options;
+        if (hasResourceChanged) {
+            this.computedLanguageId = undefined;
+        }
+        if (hasPathLabelChanged) {
+            this.computedPathLabel = undefined;
+        }
+        this.render({
+            updateIcon: hasResourceChanged || hasFileKindChanged,
+            updateDecoration: hasResourceChanged || hasFileKindChanged
+        });
+    }
+    hasFileKindChanged(newOptions) {
+        const newFileKind = newOptions?.fileKind;
+        const oldFileKind = this.options?.fileKind;
+        return newFileKind !== oldFileKind;
+    }
+    hasResourceChanged(newLabel) {
+        const newResource = toResource(newLabel);
+        const oldResource = toResource(this.label);
+        if (newResource && oldResource) {
+            return ( newResource.toString()) !== ( oldResource.toString());
+        }
+        if (!newResource && !oldResource) {
+            return false;
+        }
+        return true;
+    }
+    hasPathLabelChanged(newLabel) {
+        const newResource = toResource(newLabel);
+        return !!newResource && this.computedPathLabel !== this.labelService.getUriLabel(newResource);
+    }
+    clear() {
+        this.label = undefined;
+        this.options = undefined;
+        this.computedLanguageId = undefined;
+        this.computedIconClasses = undefined;
+        this.computedPathLabel = undefined;
+        this.setLabel('');
+    }
+    render(options) {
+        if (this.isHidden) {
+            if (this.needsRedraw !== Redraw.Full) {
+                this.needsRedraw = (options.updateIcon || options.updateDecoration) ? Redraw.Full : Redraw.Basic;
+            }
+            return false;
+        }
+        if (options.updateIcon) {
+            this.computedIconClasses = undefined;
+        }
+        if (!this.label) {
+            return false;
+        }
+        const iconLabelOptions = {
+            title: '',
+            italic: this.options?.italic,
+            strikethrough: this.options?.strikethrough,
+            matches: this.options?.matches,
+            descriptionMatches: this.options?.descriptionMatches,
+            extraClasses: [],
+            separator: this.options?.separator,
+            domId: this.options?.domId,
+            disabledCommand: this.options?.disabledCommand,
+            labelEscapeNewLines: this.options?.labelEscapeNewLines
+        };
+        const resource = toResource(this.label);
+        const label = this.label.name;
+        if (this.options?.title !== undefined) {
+            iconLabelOptions.title = this.options.title;
+        }
+        if (resource && resource.scheme !== Schemas.data
+            && ((!this.options?.title)
+                || ((typeof this.options.title !== 'string') && !this.options.title.markdownNotSupportedFallback))) {
+            if (!this.computedPathLabel) {
+                this.computedPathLabel = this.labelService.getUriLabel(resource);
+            }
+            if (!iconLabelOptions.title || (typeof iconLabelOptions.title === 'string')) {
+                iconLabelOptions.title = this.computedPathLabel;
+            }
+            else if (!iconLabelOptions.title.markdownNotSupportedFallback) {
+                iconLabelOptions.title.markdownNotSupportedFallback = this.computedPathLabel;
+            }
+        }
+        if (this.options && !this.options.hideIcon) {
+            if (!this.computedIconClasses) {
+                this.computedIconClasses = getIconClasses(this.modelService, this.languageService, resource, this.options.fileKind);
+            }
+            iconLabelOptions.extraClasses = this.computedIconClasses.slice(0);
+        }
+        if (this.options?.extraClasses) {
+            iconLabelOptions.extraClasses.push(...this.options.extraClasses);
+        }
+        if (this.options?.fileDecorations && resource) {
+            if (options.updateDecoration) {
+                this.decoration.value = this.decorationsService.getDecoration(resource, this.options.fileKind !== FileKind.FILE);
+            }
+            const decoration = this.decoration.value;
+            if (decoration) {
+                if (decoration.tooltip) {
+                    if (typeof iconLabelOptions.title === 'string') {
+                        iconLabelOptions.title = `${iconLabelOptions.title} • ${decoration.tooltip}`;
+                    }
+                    else if (typeof iconLabelOptions.title?.markdown === 'string') {
+                        const title = `${iconLabelOptions.title.markdown} • ${decoration.tooltip}`;
+                        iconLabelOptions.title = { markdown: title, markdownNotSupportedFallback: title };
+                    }
+                }
+                if (decoration.strikethrough) {
+                    iconLabelOptions.strikethrough = true;
+                }
+                if (this.options.fileDecorations.colors) {
+                    iconLabelOptions.extraClasses.push(decoration.labelClassName);
+                }
+                if (this.options.fileDecorations.badges) {
+                    iconLabelOptions.extraClasses.push(decoration.badgeClassName);
+                    iconLabelOptions.extraClasses.push(decoration.iconClassName);
+                }
+            }
+        }
+        this.setLabel(label || '', this.label.description, iconLabelOptions);
+        this._onDidRender.fire();
+        return true;
+    }
+    dispose() {
+        super.dispose();
+        this.label = undefined;
+        this.options = undefined;
+        this.computedLanguageId = undefined;
+        this.computedIconClasses = undefined;
+        this.computedPathLabel = undefined;
+        this.computedWorkspaceFolderLabel = undefined;
+    }
+};
+ResourceLabelWidget = ( __decorate([
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IDecorationsService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, IWorkspaceContextService))
+], ResourceLabelWidget));
+export { ResourceLabels };

package/dist/vscode/vs/workbench/browser/panecomposite.js

@@ -0,0 +1,158 @@
+import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { CompositeRegistry, CompositeDescriptor, Composite } from './composite.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { SubmenuItemAction } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ViewsSubMenu } from './parts/views/viewPaneContainer.js';
+import { IExtensionService } from '../services/extensions/common/extensions.js';
+import { VIEWPANE_FILTER_ACTION } from './parts/views/viewPane.js';
+let PaneComposite = class PaneComposite extends Composite {
+    constructor(id, telemetryService, storageService, instantiationService, themeService, contextMenuService, extensionService, contextService) {
+        super(id, telemetryService, themeService, storageService);
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.extensionService = extensionService;
+        this.contextService = contextService;
+    }
+    create(parent) {
+        this.viewPaneContainer = this._register(this.createViewPaneContainer(parent));
+        this._register(this.viewPaneContainer.onTitleAreaUpdate(() => this.updateTitleArea()));
+        this.viewPaneContainer.create(parent);
+    }
+    setVisible(visible) {
+        super.setVisible(visible);
+        this.viewPaneContainer?.setVisible(visible);
+    }
+    layout(dimension) {
+        this.viewPaneContainer?.layout(dimension);
+    }
+    setBoundarySashes(sashes) {
+        this.viewPaneContainer?.setBoundarySashes(sashes);
+    }
+    getOptimalWidth() {
+        return this.viewPaneContainer?.getOptimalWidth() ?? 0;
+    }
+    openView(id, focus) {
+        return this.viewPaneContainer?.openView(id, focus);
+    }
+    getViewPaneContainer() {
+        return this.viewPaneContainer;
+    }
+    getActionsContext() {
+        return this.getViewPaneContainer()?.getActionsContext();
+    }
+    getContextMenuActions() {
+        return this.viewPaneContainer?.menuActions?.getContextMenuActions() ?? [];
+    }
+    getMenuIds() {
+        const result = [];
+        if (this.viewPaneContainer?.menuActions) {
+            result.push(this.viewPaneContainer.menuActions.menuId);
+            if (this.viewPaneContainer.isViewMergedWithContainer()) {
+                result.push(this.viewPaneContainer.panes[0].menuActions.menuId);
+            }
+        }
+        return result;
+    }
+    getActions() {
+        const result = [];
+        if (this.viewPaneContainer?.menuActions) {
+            result.push(...this.viewPaneContainer.menuActions.getPrimaryActions());
+            if (this.viewPaneContainer.isViewMergedWithContainer()) {
+                const viewPane = this.viewPaneContainer.panes[0];
+                if (viewPane.shouldShowFilterInHeader()) {
+                    result.push(VIEWPANE_FILTER_ACTION);
+                }
+                result.push(...viewPane.menuActions.getPrimaryActions());
+            }
+        }
+        return result;
+    }
+    getSecondaryActions() {
+        if (!this.viewPaneContainer?.menuActions) {
+            return [];
+        }
+        const viewPaneActions = this.viewPaneContainer.isViewMergedWithContainer() ? this.viewPaneContainer.panes[0].menuActions.getSecondaryActions() : [];
+        let menuActions = this.viewPaneContainer.menuActions.getSecondaryActions();
+        const viewsSubmenuActionIndex = menuActions.findIndex(action => action instanceof SubmenuItemAction && action.item.submenu === ViewsSubMenu);
+        if (viewsSubmenuActionIndex !== -1) {
+            const viewsSubmenuAction = menuActions[viewsSubmenuActionIndex];
+            if (( viewsSubmenuAction.actions.some(({ enabled }) => enabled))) {
+                if (menuActions.length === 1 && viewPaneActions.length === 0) {
+                    menuActions = viewsSubmenuAction.actions.slice();
+                }
+                else if (viewsSubmenuActionIndex !== 0) {
+                    menuActions = [viewsSubmenuAction, ...menuActions.slice(0, viewsSubmenuActionIndex), ...menuActions.slice(viewsSubmenuActionIndex + 1)];
+                }
+            }
+            else {
+                menuActions.splice(viewsSubmenuActionIndex, 1);
+            }
+        }
+        if (menuActions.length && viewPaneActions.length) {
+            return [
+                ...menuActions,
+                ( new Separator()),
+                ...viewPaneActions
+            ];
+        }
+        return menuActions.length ? menuActions : viewPaneActions;
+    }
+    getActionViewItem(action) {
+        return this.viewPaneContainer?.getActionViewItem(action);
+    }
+    getTitle() {
+        return this.viewPaneContainer?.getTitle() ?? '';
+    }
+    focus() {
+        this.viewPaneContainer?.focus();
+    }
+};
+PaneComposite = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, IWorkspaceContextService))
+], PaneComposite));
+class PaneCompositeDescriptor extends CompositeDescriptor {
+    static create(ctor, id, name, cssClass, order, requestedIndex, iconUrl) {
+        return ( new PaneCompositeDescriptor(ctor, id, name, cssClass, order, requestedIndex, iconUrl));
+    }
+    constructor(ctor, id, name, cssClass, order, requestedIndex, iconUrl) {
+        super(ctor, id, name, cssClass, order, requestedIndex);
+        this.iconUrl = iconUrl;
+    }
+}
+const Extensions = {
+    Viewlets: 'workbench.contributions.viewlets',
+    Panels: 'workbench.contributions.panels',
+    Auxiliary: 'workbench.contributions.auxiliary',
+};
+class PaneCompositeRegistry extends CompositeRegistry {
+    registerPaneComposite(descriptor) {
+        super.registerComposite(descriptor);
+    }
+    deregisterPaneComposite(id) {
+        super.deregisterComposite(id);
+    }
+    getPaneComposite(id) {
+        return this.getComposite(id);
+    }
+    getPaneComposites() {
+        return this.getComposites();
+    }
+}
+Registry.add(Extensions.Viewlets, ( new PaneCompositeRegistry()));
+Registry.add(Extensions.Panels, ( new PaneCompositeRegistry()));
+Registry.add(Extensions.Auxiliary, ( new PaneCompositeRegistry()));
+export { Extensions, PaneComposite, PaneCompositeDescriptor, PaneCompositeRegistry };

package/dist/vscode/vs/workbench/browser/part.js

@@ -0,0 +1,84 @@
+import "../../../../assets/part.css";
+import { Component } from '../common/component.js';
+import { Dimension, size } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+class Part extends Component {
+    get dimension() { return this._dimension; }
+    constructor(id, options, themeService, storageService, layoutService) {
+        super(id, themeService, storageService);
+        this.options = options;
+        this.layoutService = layoutService;
+        this._onDidVisibilityChange = this._register(( new Emitter()));
+        this.onDidVisibilityChange = this._onDidVisibilityChange.event;
+        this._onDidChange = this._register(( new Emitter()));
+        layoutService.registerPart(this);
+    }
+    onThemeChange(theme) {
+        if (this.parent) {
+            super.onThemeChange(theme);
+        }
+    }
+    updateStyles() {
+        super.updateStyles();
+    }
+    create(parent, options) {
+        this.parent = parent;
+        this.titleArea = this.createTitleArea(parent, options);
+        this.contentArea = this.createContentArea(parent, options);
+        this.partLayout = ( new PartLayout(this.options, this.contentArea));
+        this.updateStyles();
+    }
+    getContainer() {
+        return this.parent;
+    }
+    createTitleArea(parent, options) {
+        return undefined;
+    }
+    getTitleArea() {
+        return this.titleArea;
+    }
+    createContentArea(parent, options) {
+        return undefined;
+    }
+    getContentArea() {
+        return this.contentArea;
+    }
+    layoutContents(width, height) {
+        const partLayout = assertIsDefined(this.partLayout);
+        return partLayout.layout(width, height);
+    }
+    get onDidChange() { return this._onDidChange.event; }
+    layout(width, height, _top, _left) {
+        this._dimension = ( new Dimension(width, height));
+    }
+    setVisible(visible) {
+        this._onDidVisibilityChange.fire(visible);
+    }
+}
+class PartLayout {
+    constructor(options, contentArea) {
+        this.options = options;
+        this.contentArea = contentArea;
+    }
+    layout(width, height) {
+        let titleSize;
+        if (this.options.hasTitle) {
+            titleSize = ( new Dimension(width, Math.min(height, PartLayout.TITLE_HEIGHT)));
+        }
+        else {
+            titleSize = Dimension.None;
+        }
+        let contentWidth = width;
+        if (this.options && typeof this.options.borderWidth === 'function') {
+            contentWidth -= this.options.borderWidth();
+        }
+        const contentSize = ( new Dimension(contentWidth, height - titleSize.height));
+        if (this.contentArea) {
+            size(this.contentArea, contentSize.width, contentSize.height);
+        }
+        return { titleSize, contentSize };
+    }
+}
+PartLayout.TITLE_HEIGHT = 35;
+export { Part };