@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/service-override/views.d.ts

@@ -0,0 +1,502 @@
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import { A as ActionBar, q as IContextMenuProvider, r as ActionsOrientation, s as IActionViewItemProvider, t as AnchorAlignment, u as IMenuService, v as IContextMenuService, j as ITelemetryService, M as MenuId, w as IMenuActionOptions, x as Composite, y as Part, n as IStorageService, z as CompositeRegistry, B as IWorkbenchLayoutService, m as IThemeService, D as IPartOptions, E as IActionViewItem, F as IBoundarySashes, G as IView, d as IPaneComposite, P as PaneCompositeDescriptor, e as IBadge, H as PaneComposite, L as LayoutPriority, J as IViewDescriptorService, l as IConfigurationService, k as IWorkbenchEnvironmentService, K as HoverPosition, N as Dimension, O as Parts, V as ViewContainerLocation } from '../activity.js';
+import { I as IInstantiationService } from '../instantiation.js';
+import { D as Disposable, E as Event, b as Emitter, I as IDisposable } from '../event.js';
+import { I as IContextKeyService, a as IContextKey } from '../contextkey.js';
+import { v as IActionRunner, c as IAction, w as IComposite, e as INotificationService, b as IProgressIndicator, d as ICommandService } from '../colorRegistry.js';
+import { R as ResolvedKeybinding, a as IKeybindingService } from '../keybinding.js';
+import { T as ThemeIcon } from '../themables.js';
+import { a as IExtensionService } from '../extensionsRegistry.js';
+import 'monaco-editor';
+import '../uri.js';
+import '../editor.js';
+import '../files.js';
+import '../extensions.d2.ts';
+import '../jsonSchema.js';
+import '../workspace.js';
+import 'vscode';
+
+interface IToolBarOptions {
+    orientation?: ActionsOrientation;
+    actionViewItemProvider?: IActionViewItemProvider;
+    ariaLabel?: string;
+    getKeyBinding?: (action: IAction) => ResolvedKeybinding | undefined;
+    actionRunner?: IActionRunner;
+    toggleMenuTitle?: string;
+    anchorAlignmentProvider?: () => AnchorAlignment;
+    renderDropdownAsChildElement?: boolean;
+    moreIcon?: ThemeIcon;
+    allowContextMenu?: boolean;
+}
+/**
+ * A widget that combines an action bar for primary actions and a dropdown for secondary actions.
+ */
+declare class ToolBar extends Disposable {
+    private options;
+    protected readonly actionBar: ActionBar;
+    private toggleMenuAction;
+    private toggleMenuActionViewItem;
+    private submenuActionViewItems;
+    private hasSecondaryActions;
+    private readonly lookupKeybindings;
+    private readonly element;
+    private _onDidChangeDropdownVisibility;
+    readonly onDidChangeDropdownVisibility: Event<boolean>;
+    private disposables;
+    constructor(container: HTMLElement, contextMenuProvider: IContextMenuProvider, options?: IToolBarOptions);
+    set actionRunner(actionRunner: IActionRunner);
+    get actionRunner(): IActionRunner;
+    set context(context: unknown);
+    getElement(): HTMLElement;
+    focus(): void;
+    getItemsWidth(): number;
+    getItemAction(indexOrElement: number | HTMLElement): IAction | undefined;
+    getItemWidth(index: number): number;
+    getItemsLength(): number;
+    setAriaLabel(label: string): void;
+    setActions(primaryActions: ReadonlyArray<IAction>, secondaryActions?: ReadonlyArray<IAction>): void;
+    isEmpty(): boolean;
+    private getKeybindingLabel;
+    private clear;
+    dispose(): void;
+}
+
+declare const enum HiddenItemStrategy {
+    /** This toolbar doesn't support hiding*/
+    NoHide = -1,
+    /** Hidden items aren't shown anywhere */
+    Ignore = 0,
+    /** Hidden items move into the secondary group */
+    RenderInSecondaryGroup = 1
+}
+type IWorkbenchToolBarOptions = IToolBarOptions & {
+    /**
+     * Items of the primary group can be hidden. When this happens the item can
+     * - move into the secondary popup-menu, or
+     * - not be shown at all
+     */
+    hiddenItemStrategy?: HiddenItemStrategy;
+    /**
+     * Optional menu id which is used for a "Reset Menu" command. This should be the
+     * menu id that defines the contents of this workbench menu
+     */
+    resetMenu?: MenuId;
+    /**
+     * Optional menu id which items are used for the context menu of the toolbar.
+     */
+    contextMenu?: MenuId;
+    /**
+     * Optional options how menu actions are created and invoked
+     */
+    menuOptions?: IMenuActionOptions;
+    /**
+     * When set the `workbenchActionExecuted` is automatically send for each invoked action. The `from` property
+     * of the event will the passed `telemetrySource`-value
+     */
+    telemetrySource?: string;
+    /** This is controlled by the WorkbenchToolBar */
+    allowContextMenu?: never;
+    /**
+     * Maximun number of items that can shown. Extra items will be shown in the overflow menu.
+     */
+    maxNumberOfItems?: number;
+};
+/**
+ * The `WorkbenchToolBar` does
+ * - support hiding of menu items
+ * - lookup keybindings for each actions automatically
+ * - send `workbenchActionExecuted`-events for each action
+ *
+ * See {@link MenuWorkbenchToolBar} for a toolbar that is backed by a menu.
+ */
+declare class WorkbenchToolBar extends ToolBar {
+    private _options;
+    private readonly _menuService;
+    private readonly _contextKeyService;
+    private readonly _contextMenuService;
+    private readonly _sessionDisposables;
+    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    setActions(_primary: readonly IAction[], _secondary?: readonly IAction[], menuIds?: readonly MenuId[]): void;
+}
+
+interface ICompositeTitleLabel {
+    /**
+     * Asks to update the title for the composite with the given ID.
+     */
+    updateTitle(id: string, title: string, keybinding?: string): void;
+    /**
+     * Called when theming information changes.
+     */
+    updateStyles(): void;
+}
+declare abstract class CompositePart<T extends Composite> extends Part {
+    private readonly notificationService;
+    protected readonly storageService: IStorageService;
+    private readonly telemetryService;
+    protected readonly contextMenuService: IContextMenuService;
+    protected readonly keybindingService: IKeybindingService;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly registry: CompositeRegistry<T>;
+    private readonly activeCompositeSettingsKey;
+    private readonly defaultCompositeId;
+    private readonly nameForTelemetry;
+    private readonly compositeCSSClass;
+    private readonly titleForegroundColor;
+    protected readonly onDidCompositeOpen: Emitter<{
+        composite: IComposite;
+        focus: boolean;
+    }>;
+    protected readonly onDidCompositeClose: Emitter<IComposite>;
+    protected toolBar: WorkbenchToolBar | undefined;
+    protected titleLabelElement: HTMLElement | undefined;
+    private readonly mapCompositeToCompositeContainer;
+    private readonly mapActionsBindingToComposite;
+    private activeComposite;
+    private lastActiveCompositeId;
+    private readonly instantiatedCompositeItems;
+    private titleLabel;
+    private progressBar;
+    private contentAreaSize;
+    private readonly telemetryActionsListener;
+    private currentCompositeOpenToken;
+    private boundarySashes;
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, registry: CompositeRegistry<T>, activeCompositeSettingsKey: string, defaultCompositeId: string, nameForTelemetry: string, compositeCSSClass: string, titleForegroundColor: string | undefined, id: string, options: IPartOptions);
+    protected openComposite(id: string, focus?: boolean): Composite | undefined;
+    private doOpenComposite;
+    protected createComposite(id: string, isActive?: boolean): Composite;
+    protected showComposite(composite: Composite): void;
+    protected onTitleAreaUpdate(compositeId: string): void;
+    private updateTitle;
+    private collectCompositeActions;
+    protected getActiveComposite(): IComposite | undefined;
+    protected getLastActiveCompositeId(): string;
+    protected hideActiveComposite(): Composite | undefined;
+    protected createTitleArea(parent: HTMLElement): HTMLElement;
+    protected createTitleLabel(parent: HTMLElement): ICompositeTitleLabel;
+    updateStyles(): void;
+    protected actionViewItemProvider(action: IAction): IActionViewItem | undefined;
+    protected actionsContextProvider(): unknown;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    getProgressIndicator(id: string): IProgressIndicator | undefined;
+    protected getTitleAreaDropDownAnchorAlignment(): AnchorAlignment;
+    layout(width: number, height: number, top: number, left: number): void;
+    setBoundarySashes?(sashes: IBoundarySashes): void;
+    protected removeComposite(compositeId: string): boolean;
+    dispose(): void;
+}
+
+interface IPaneCompositePart extends IView {
+    readonly onDidPaneCompositeOpen: Event<IPaneComposite>;
+    readonly onDidPaneCompositeClose: Event<IPaneComposite>;
+    /**
+     * Opens a viewlet with the given identifier and pass keyboard focus to it if specified.
+     */
+    openPaneComposite(id: string | undefined, focus?: boolean): Promise<IPaneComposite | undefined>;
+    /**
+     * Returns the current active viewlet if any.
+     */
+    getActivePaneComposite(): IPaneComposite | undefined;
+    /**
+     * Returns the viewlet by id.
+     */
+    getPaneComposite(id: string): PaneCompositeDescriptor | undefined;
+    /**
+     * Returns all enabled viewlets
+     */
+    getPaneComposites(): PaneCompositeDescriptor[];
+    /**
+     * Returns the progress indicator for the side bar.
+     */
+    getProgressIndicator(id: string): IProgressIndicator | undefined;
+    /**
+     * Hide the active viewlet.
+     */
+    hideActivePaneComposite(): void;
+    /**
+     * Return the last active viewlet id.
+     */
+    getLastActivePaneCompositeId(): string;
+}
+interface IPaneCompositeSelectorPart {
+    /**
+     * Returns id of pinned view containers following the visual order.
+     */
+    getPinnedPaneCompositeIds(): string[];
+    /**
+     * Returns id of visible view containers following the visual order.
+     */
+    getVisiblePaneCompositeIds(): string[];
+    /**
+     * Show an activity in a viewlet.
+     */
+    showActivity(id: string, badge: IBadge, clazz?: string, priority?: number): IDisposable;
+}
+
+declare class SidebarPart extends CompositePart<PaneComposite> implements IPaneCompositePart {
+    private readonly viewDescriptorService;
+    private readonly contextKeyService;
+    private readonly extensionService;
+    readonly _serviceBrand: undefined;
+    static readonly activeViewletSettingsKey = "workbench.sidebar.activeviewletid";
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    readonly priority: LayoutPriority;
+    readonly snap = true;
+    get preferredWidth(): number | undefined;
+    get onDidPaneCompositeRegister(): Event<PaneCompositeDescriptor>;
+    private _onDidViewletDeregister;
+    readonly onDidPaneCompositeDeregister: Event<PaneCompositeDescriptor>;
+    get onDidPaneCompositeOpen(): Event<IPaneComposite>;
+    get onDidPaneCompositeClose(): Event<IPaneComposite>;
+    private readonly viewletRegistry;
+    private readonly sideBarFocusContextKey;
+    private readonly activeViewletContextKey;
+    private blockOpeningViewlet;
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, extensionService: IExtensionService);
+    private registerListeners;
+    create(parent: HTMLElement): void;
+    protected createTitleArea(parent: HTMLElement): HTMLElement;
+    updateStyles(): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    getActivePaneComposite(): IPaneComposite | undefined;
+    getLastActivePaneCompositeId(): string;
+    hideActivePaneComposite(): void;
+    openPaneComposite(id: string | undefined, focus?: boolean): Promise<IPaneComposite | undefined>;
+    getPaneComposites(): PaneCompositeDescriptor[];
+    getPaneComposite(id: string): PaneCompositeDescriptor;
+    private doOpenViewlet;
+    protected getTitleAreaDropDownAnchorAlignment(): AnchorAlignment;
+    private onTitleAreaContextMenu;
+    toJSON(): object;
+}
+
+declare class ActivitybarPart extends Part implements IPaneCompositeSelectorPart {
+    private readonly paneCompositePart;
+    private readonly instantiationService;
+    private readonly storageService;
+    private readonly extensionService;
+    private readonly viewDescriptorService;
+    private readonly contextKeyService;
+    private readonly configurationService;
+    private readonly environmentService;
+    readonly _serviceBrand: undefined;
+    private static readonly PINNED_VIEW_CONTAINERS;
+    private static readonly PLACEHOLDER_VIEW_CONTAINERS;
+    private static readonly ACTION_HEIGHT;
+    private static readonly ACCOUNTS_ACTION_INDEX;
+    private static readonly GEAR_ICON;
+    private static readonly ACCOUNTS_ICON;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    private content;
+    private menuBar;
+    private menuBarContainer;
+    private compositeBar;
+    private compositeBarContainer;
+    private globalActivityAction;
+    private globalActivityActionBar;
+    private globalActivitiesContainer;
+    private readonly globalActivity;
+    private accountsActivityAction;
+    private readonly accountsActivity;
+    private readonly compositeActions;
+    private readonly viewContainerDisposables;
+    private readonly keyboardNavigationDisposables;
+    private readonly location;
+    private hasExtensionsRegistered;
+    private readonly enabledViewContainersContextKeys;
+    constructor(paneCompositePart: IPaneCompositePart, instantiationService: IInstantiationService, layoutService: IWorkbenchLayoutService, themeService: IThemeService, storageService: IStorageService, extensionService: IExtensionService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService);
+    private createCompositeBar;
+    private getActivityHoverOptions;
+    private getContextMenuActionsForComposite;
+    private registerListeners;
+    private onDidChangeViewContainers;
+    private onDidChangeViewContainerLocation;
+    private onDidChangeViewContainerVisibility;
+    private onDidRegisterExtensions;
+    private onDidViewContainerVisible;
+    showActivity(viewContainerOrActionId: string, badge: IBadge, clazz?: string, priority?: number): IDisposable;
+    private showGlobalActivity;
+    private removeGlobalActivity;
+    private updateGlobalActivity;
+    private getCumulativeNumberBadge;
+    private uninstallMenubar;
+    private installMenubar;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private registerKeyboardNavigationListeners;
+    private createGlobalActivityActionBar;
+    private toggleAccountsActivity;
+    private getCompositeActions;
+    private onDidRegisterViewContainers;
+    private onDidDeregisterViewContainer;
+    private updateActivity;
+    private toActivity;
+    private static toActivity;
+    private showOrHideViewContainer;
+    private shouldBeHidden;
+    private addComposite;
+    private hideComposite;
+    private removeComposite;
+    getPinnedPaneCompositeIds(): string[];
+    getVisiblePaneCompositeIds(): string[];
+    focus(): void;
+    updateStyles(): void;
+    private getActivitybarItemColors;
+    layout(width: number, height: number): void;
+    private getViewContainer;
+    private getViewContainers;
+    private onDidStorageValueChange;
+    private saveCachedViewContainers;
+    private _cachedViewContainers;
+    private get cachedViewContainers();
+    private storeCachedViewContainersState;
+    private getPinnedViewContainers;
+    private setPinnedViewContainers;
+    private _pinnedViewContainersValue;
+    private get pinnedViewContainersValue();
+    private set pinnedViewContainersValue(value);
+    private getStoredPinnedViewContainersValue;
+    private setStoredPinnedViewContainersValue;
+    private getPlaceholderViewContainers;
+    private setPlaceholderViewContainers;
+    private _placeholderViewContainersValue;
+    private get placeholderViewContainersValue();
+    private set placeholderViewContainersValue(value);
+    private getStoredPlaceholderViewContainersValue;
+    private setStoredPlaceholderViewContainersValue;
+    private get accountsVisibilityPreference();
+    private set accountsVisibilityPreference(value);
+    toJSON(): object;
+}
+
+interface IActivityHoverOptions {
+    readonly position: () => HoverPosition;
+}
+
+interface IPanelPartOptions extends IPartOptions {
+    hasTitle: true;
+    borderWidth?: (() => number);
+    useIcons?: boolean;
+}
+declare abstract class BasePanelPart extends CompositePart<PaneComposite> implements IPaneCompositePart, IPaneCompositeSelectorPart {
+    private readonly viewDescriptorService;
+    protected readonly contextKeyService: IContextKeyService;
+    private readonly extensionService;
+    private readonly partId;
+    private readonly pinnedPanelsKey;
+    private readonly placeholdeViewContainersKey;
+    private readonly backgroundColor;
+    private readonly viewContainerLocation;
+    private readonly activePanelContextKey;
+    private panelFocusContextKey;
+    private readonly panelOptions;
+    private static readonly MIN_COMPOSITE_BAR_WIDTH;
+    readonly _serviceBrand: undefined;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    readonly snap = true;
+    get preferredHeight(): number | undefined;
+    get preferredWidth(): number | undefined;
+    get onDidPaneCompositeOpen(): Event<IPaneComposite>;
+    readonly onDidPaneCompositeClose: Event<IPaneComposite>;
+    private compositeBar;
+    private readonly compositeActions;
+    private globalToolBar;
+    private globalActions;
+    private readonly panelDisposables;
+    private blockOpeningPanel;
+    protected contentDimension: Dimension | undefined;
+    private extensionsRegistered;
+    private panelRegistry;
+    private dndHandler;
+    private readonly enabledViewContainersContextKeys;
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, extensionService: IExtensionService, partId: Parts.PANEL_PART | Parts.AUXILIARYBAR_PART, activePanelSettingsKey: string, pinnedPanelsKey: string, placeholdeViewContainersKey: string, panelRegistryId: string, backgroundColor: string, viewContainerLocation: ViewContainerLocation, activePanelContextKey: IContextKey<string>, panelFocusContextKey: IContextKey<boolean>, panelOptions: IPanelPartOptions);
+    protected abstract getActivityHoverOptions(): IActivityHoverOptions;
+    protected abstract fillExtraContextMenuActions(actions: IAction[]): void;
+    private getContextMenuActionsForComposite;
+    private onDidRegisterPanels;
+    private onDidDeregisterPanel;
+    private updateActivity;
+    private toActivity;
+    private static toActivity;
+    private showOrHideViewContainer;
+    private shouldBeHidden;
+    private registerListeners;
+    private onDidRegisterExtensions;
+    private hideComposite;
+    private onPanelOpen;
+    private onPanelClose;
+    create(parent: HTMLElement): void;
+    private createEmptyPanelMessage;
+    protected createTitleArea(parent: HTMLElement): HTMLElement;
+    updateStyles(): void;
+    doOpenPanel(id: string, focus?: boolean): PaneComposite | undefined;
+    openPaneComposite(id?: string, focus?: boolean): Promise<PaneComposite | undefined>;
+    showActivity(panelId: string, badge: IBadge, clazz?: string): IDisposable;
+    getPaneComposite(panelId: string): PaneCompositeDescriptor | undefined;
+    getPaneComposites(): PaneCompositeDescriptor[];
+    getPinnedPaneCompositeIds(): string[];
+    getVisiblePaneCompositeIds(): string[];
+    getActivePaneComposite(): IPaneComposite | undefined;
+    getLastActivePaneCompositeId(): string;
+    hideActivePaneComposite(): void;
+    protected createTitleLabel(parent: HTMLElement): ICompositeTitleLabel;
+    protected onTitleAreaUpdate(compositeId: string): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    private layoutCompositeBar;
+    private emptyPanelMessageElement;
+    private layoutEmptyMessage;
+    private getViewContainer;
+    private updateGlobalToolbarActions;
+    private getCompositeActions;
+    protected removeComposite(compositeId: string): boolean;
+    protected getToolbarWidth(): number;
+    private onDidStorageValueChange;
+    private saveCachedPanels;
+    private getCachedPanels;
+    private _cachedPanelsValue;
+    private get cachedPanelsValue();
+    private set cachedPanelsValue(value);
+    private getStoredCachedPanelsValue;
+    private setStoredCachedViewletsValue;
+    private getPlaceholderViewContainers;
+    private setPlaceholderViewContainers;
+    private _placeholderViewContainersValue;
+    private get placeholderViewContainersValue();
+    private set placeholderViewContainersValue(value);
+    private getStoredPlaceholderViewContainersValue;
+    private setStoredPlaceholderViewContainersValue;
+}
+declare class PanelPart extends BasePanelPart {
+    private commandService;
+    private menuService;
+    static readonly activePanelSettingsKey = "workbench.panelpart.activepanelid";
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, extensionService: IExtensionService, commandService: ICommandService, menuService: IMenuService);
+    updateStyles(): void;
+    protected getActivityHoverOptions(): IActivityHoverOptions;
+    protected fillExtraContextMenuActions(actions: IAction[]): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    toJSON(): object;
+}
+
+declare function createActivitybarPar(container: HTMLElement): ActivitybarPart;
+declare function createSidebarPart(container: HTMLElement): SidebarPart;
+declare function createPanelPart(container: HTMLElement): PanelPart;
+interface CustomViewOption {
+    id: string;
+    name: string;
+    renderBody(container: HTMLElement): IDisposable;
+    location: ViewContainerLocation;
+    icon?: string;
+    canMoveView?: boolean;
+}
+declare function registerCustomView(options: CustomViewOption): IDisposable;
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { CustomViewOption, ViewContainerLocation, createActivitybarPar, createPanelPart, createSidebarPart, getServiceOverride as default, registerCustomView };

package/dist/service-override/views.js

@@ -0,0 +1,177 @@
+import '../vscode-services/missing-services.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Extensions, IViewsService, IViewDescriptorService } from '../vscode/vs/workbench/common/views.js';
+export { ViewContainerLocation } from '../vscode/vs/workbench/common/views.js';
+import { ViewsService } from '../vscode/vs/workbench/browser/parts/views/viewsService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { SidebarPart } from '../vscode/vs/workbench/browser/parts/sidebar/sidebarPart.js';
+import { ViewDescriptorService } from '../vscode/vs/workbench/services/views/browser/viewDescriptorService.js';
+import { IActivityService } from '../vscode/vs/workbench/services/activity/common/activity.js';
+import { ActivityService } from '../vscode/vs/workbench/services/activity/browser/activityService.js';
+import { IPaneCompositePartService } from '../vscode/vs/workbench/services/panecomposite/browser/panecomposite.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ActivitybarPart } from '../vscode/vs/workbench/browser/parts/activitybar/activitybarPart.js';
+import { IHoverService } from '../vscode/vs/workbench/services/hover/browser/hover.js';
+import { HoverService } from '../vscode/vs/workbench/services/hover/browser/hoverService.js';
+import { ExplorerService } from '../vscode/vs/workbench/contrib/files/browser/explorerService.js';
+import { IExplorerService } from '../vscode/vs/workbench/contrib/files/browser/files.js';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { BulkEditService } from '../vscode/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js';
+import { PanelPart } from '../vscode/vs/workbench/browser/parts/panel/panelPart.js';
+import { $, append } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ViewPane } from '../vscode/vs/workbench/browser/parts/views/viewPane.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ViewPaneContainer } from '../vscode/vs/workbench/browser/parts/views/viewPaneContainer.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import getServiceOverride$1 from './layout.js';
+import '../vscode/vs/workbench/contrib/files/browser/fileCommands.js';
+import '../vscode/vs/workbench/contrib/files/browser/fileActions.contribution.js';
+import '../vscode/vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution.js';
+import '../vscode/vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution.js';
+import '../vscode/vs/workbench/browser/actions/listCommands.js';
+import "../assets/views.css";
+import '../vscode/vs/workbench/api/browser/viewsExtensionPoint.js';
+const paneCompositeParts = new Map();
+const paneCompositeSelectorParts = new Map();
+class PaneCompositePartService {
+    constructor() {
+        this.onDidPaneCompositeOpen = Event.None;
+        this.onDidPaneCompositeClose = Event.None;
+    }
+    async openPaneComposite(id, viewContainerLocation, focus) {
+        return this.getPartByLocation(viewContainerLocation)?.openPaneComposite(id, focus);
+    }
+    getActivePaneComposite(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation)?.getActivePaneComposite();
+    }
+    getPaneComposite(id, viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation)?.getPaneComposite(id);
+    }
+    getPaneComposites(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getPaneComposites();
+    }
+    getPinnedPaneCompositeIds(viewContainerLocation) {
+        return this.getSelectorPartByLocation(viewContainerLocation).getPinnedPaneCompositeIds();
+    }
+    getVisiblePaneCompositeIds(viewContainerLocation) {
+        return this.getSelectorPartByLocation(viewContainerLocation).getVisiblePaneCompositeIds();
+    }
+    getProgressIndicator(id, viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getProgressIndicator(id);
+    }
+    hideActivePaneComposite(viewContainerLocation) {
+        this.getPartByLocation(viewContainerLocation).hideActivePaneComposite();
+    }
+    getLastActivePaneCompositeId(viewContainerLocation) {
+        return this.getPartByLocation(viewContainerLocation).getLastActivePaneCompositeId();
+    }
+    showActivity(id, viewContainerLocation, badge, clazz, priority) {
+        return this.getSelectorPartByLocation(viewContainerLocation).showActivity(id, badge, clazz, priority);
+    }
+    getPartByLocation(viewContainerLocation) {
+        return paneCompositeParts.get(viewContainerLocation);
+    }
+    getSelectorPartByLocation(viewContainerLocation) {
+        return paneCompositeSelectorParts.get(viewContainerLocation);
+    }
+}
+function renderPart(part, container, classNames) {
+    const panelEl = document.createElement('div');
+    container.append(panelEl);
+    panelEl.classList.add(...classNames);
+    panelEl.oncontextmenu = () => false;
+    part.create(panelEl);
+    function layout() {
+        part.layout(Math.max(part.minimumWidth, Math.min(part.maximumWidth, container.offsetWidth)), Math.max(part.minimumHeight, Math.min(part.maximumHeight, container.offsetHeight)), 0, 0);
+    }
+    part.onDidVisibilityChange((visible) => {
+        if (visible) {
+            layout();
+        }
+    });
+    layout();
+    const observer = new ResizeObserver(layout);
+    observer.observe(container);
+    return {
+        dispose() {
+            return observer.disconnect();
+        }
+    };
+}
+function createActivitybarPar(container) {
+    const activitybarPart = StandaloneServices.get(IInstantiationService).createInstance(ActivitybarPart, paneCompositeParts.get(0 ));
+    paneCompositeSelectorParts.set(0 , activitybarPart);
+    activitybarPart['_register'](renderPart(activitybarPart, container, ['part', 'activitybar', 'left']));
+    return activitybarPart;
+}
+function createSidebarPart(container) {
+    const sidebarPart = StandaloneServices.get(IInstantiationService).createInstance(SidebarPart);
+    paneCompositeParts.set(0 , sidebarPart);
+    sidebarPart['_register'](renderPart(sidebarPart, container, ['part', 'sidebar', 'left']));
+    if (sidebarPart.getPaneComposites().length > 0) {
+        void sidebarPart.openPaneComposite(sidebarPart.getPaneComposites()[0].id);
+    }
+    return sidebarPart;
+}
+function createPanelPart(container) {
+    const panelPart = StandaloneServices.get(IInstantiationService).createInstance(PanelPart);
+    paneCompositeSelectorParts.set(1 , panelPart);
+    paneCompositeParts.set(1 , panelPart);
+    panelPart['_register'](renderPart(panelPart, container, ['part', 'panel', 'basepanel']));
+    if (panelPart.getPaneComposites().length > 0) {
+        void panelPart.openPaneComposite(panelPart.getPaneComposites()[0].id);
+    }
+    return panelPart;
+}
+function registerCustomView(options) {
+    const iconUrl = options.icon != null ? ( URI.parse(options.icon)) : undefined;
+    const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+        id: options.id,
+        title: options.name,
+        ctorDescriptor: new SyncDescriptor(ViewPaneContainer, [options.id, { mergeViewWithContainerWhenSingleView: true }]),
+        hideIfEmpty: true,
+        icon: iconUrl
+    }, options.location);
+    const views = [{
+            id: options.id,
+            name: options.name,
+            canToggleVisibility: false,
+            ctorDescriptor: new SyncDescriptor(class extends ViewPane {
+                renderBody(container) {
+                    super.renderBody(container);
+                    this.content = $('.view-pane-content');
+                    this.content.style.display = 'flex';
+                    this.content.style.alignItems = 'stretch';
+                    append(container, this.content);
+                    this._register(options.renderBody(this.content));
+                }
+                layoutBody(height, width) {
+                    this.content.style.height = `${height}px`;
+                    this.content.style.width = `${width}px`;
+                }
+            }),
+            canMoveView: options.canMoveView ?? true,
+            containerIcon: iconUrl
+        }];
+    ( Registry.as(Extensions.ViewsRegistry)).registerViews(views, VIEW_CONTAINER);
+    return {
+        dispose() {
+            ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(views, VIEW_CONTAINER);
+            ( Registry.as(Extensions.ViewContainersRegistry)).deregisterViewContainer(VIEW_CONTAINER);
+        }
+    };
+}
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( IViewsService.toString())]: new SyncDescriptor(ViewsService),
+        [( IViewDescriptorService.toString())]: new SyncDescriptor(ViewDescriptorService),
+        [( IActivityService.toString())]: new SyncDescriptor(ActivityService),
+        [( IPaneCompositePartService.toString())]: new SyncDescriptor(PaneCompositePartService),
+        [( IHoverService.toString())]: new SyncDescriptor(HoverService),
+        [( IExplorerService.toString())]: new SyncDescriptor(ExplorerService),
+        [( IBulkEditService.toString())]: new SyncDescriptor(BulkEditService)
+    };
+}
+export { createActivitybarPar, createPanelPart, createSidebarPart, getServiceOverride as default, registerCustomView };