@codingame/monaco-vscode-api 1.81.2 → 1.81.3-next.0

package/dist/lifecycle.js

@@ -0,0 +1,47 @@
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from './vscode/vs/workbench/common/contributions.js';
+import { ILifecycleService } from './vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
+import { Barrier, RunOnceScheduler, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+const renderWorkbenchEmitter = new Emitter();
+const onRenderWorkbench = renderWorkbenchEmitter.event;
+const serviceInitializedBarrier = new Barrier();
+const serviceInitializePreParticipants = [];
+const serviceInitializeParticipants = [];
+const serviceInitializePostParticipants = [];
+function registerServiceInitializePreParticipant(participant) {
+    serviceInitializePreParticipants.push(participant);
+}
+function registerServiceInitializeParticipant(participant) {
+    serviceInitializeParticipants.push(participant);
+}
+function registerServiceInitializePostParticipant(participant) {
+    serviceInitializePostParticipants.push(participant);
+}
+async function startup(instantiationService) {
+    await instantiationService.invokeFunction(async (accessor) => {
+        await Promise.all(( serviceInitializePreParticipants.map(participant => participant(accessor))));
+    });
+    await instantiationService.invokeFunction(async (accessor) => {
+        const lifecycleService = accessor.get(ILifecycleService);
+        await Promise.all(( serviceInitializeParticipants.map(participant => participant(accessor))));
+        lifecycleService.phase = 2 ;
+    });
+    await instantiationService.invokeFunction(async (accessor) => {
+        await Promise.all(( serviceInitializePostParticipants.map(participant => participant(accessor))));
+    });
+    serviceInitializedBarrier.open();
+    instantiationService.invokeFunction(accessor => {
+        const lifecycleService = accessor.get(ILifecycleService);
+        ( Registry.as(Extensions.Workbench)).start(accessor);
+        renderWorkbenchEmitter.fire(accessor);
+        lifecycleService.phase = 3 ;
+        const eventuallyPhaseScheduler = new RunOnceScheduler(() => {
+            runWhenIdle(() => {
+                lifecycleService.phase = 4 ;
+            }, 2500);
+        }, 2500);
+        eventuallyPhaseScheduler.schedule();
+    });
+}
+export { onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant, serviceInitializedBarrier, startup };

package/dist/service-override/configuration.js

@@ -33,7 +33,7 @@ import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import '../vscode/vs/workbench/api/common/configurationExtensionPoint.js';
 import getServiceOverride$1 from './files.js';
 import { memoizedConstructor, unsupported } from '../tools.js';
-import { registerServiceInitializePreParticipant } from '../services.js';
+import { registerServiceInitializePreParticipant } from '../lifecycle.js';
 async function updateUserConfiguration(configurationJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString(configurationJson));

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

@@ -1,17 +1,46 @@
 import { IEditorOverrideServices } from '../vscode/vs/editor/standalone/browser/standaloneServices.js';
-import { IWorkbenchLayoutService, Position, Parts } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService, Parts, PanelAlignment, Position } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 import { ILayoutService, ILayoutOffsetInfo } from '../vscode/vs/platform/layout/browser/layoutService.js';
 import { Event } from '../vscode/vs/base/common/event.js';
 import { Dimension, IDimension } from '../vscode/vs/base/browser/dom.js';
 import { Part } from '../vscode/vs/workbench/browser/part.js';
-import { IPaneCompositePartService } from '../vscode/vs/workbench/services/panecomposite/browser/panecomposite.js';
+import { ServicesAccessor } from '../vscode/vs/platform/instantiation/common/instantiation.js';
 
-declare class LayoutService implements ILayoutService, Pick<IWorkbenchLayoutService, 'isVisible' | 'onDidChangePartVisibility' | 'isRestored' | 'registerPart' | 'getSideBarPosition' | 'setPartHidden' | 'hasFocus' | 'getPanelPosition' | 'isPanelMaximized' | 'getMaximumEditorDimensions' | 'onDidChangeFullscreen'> {
+declare class LayoutService implements ILayoutService, IWorkbenchLayoutService {
     container: HTMLElement;
-    private paneCompositeService;
     readonly _serviceBrand: undefined;
-    constructor(container: HTMLElement, paneCompositeService: IPaneCompositePartService);
+    private paneCompositeService;
+    private editorGroupService;
+    private statusBarService;
+    private viewDescriptorService;
+    constructor(container: HTMLElement);
     onDidChangeFullscreen: Event<any>;
+    onDidChangeZenMode: Event<any>;
+    onDidChangeWindowMaximized: Event<any>;
+    onDidChangeCenteredLayout: Event<any>;
+    onDidChangePanelPosition: Event<any>;
+    onDidChangePanelAlignment: Event<any>;
+    onDidChangeNotificationsVisibility: Event<any>;
+    openedDefaultEditors: boolean;
+    whenRestored: Promise<void>;
+    init(accessor: ServicesAccessor): void;
+    focusPart(part: Parts): void;
+    getDimension(part: Parts): Dimension | undefined;
+    toggleMaximizedPanel(): void;
+    hasWindowBorder(): boolean;
+    getWindowBorderWidth(): number;
+    getWindowBorderRadius(): string | undefined;
+    toggleMenuBar(): void;
+    setPanelPosition(): void;
+    getPanelAlignment(): PanelAlignment;
+    setPanelAlignment(): void;
+    toggleZenMode(): void;
+    isEditorLayoutCentered(): boolean;
+    centerEditorLayout(): void;
+    resizePart(): void;
+    isWindowMaximized(): boolean;
+    updateWindowMaximizedState(): void;
+    getVisibleNeighborPart(): Parts | undefined;
     getMaximumEditorDimensions(): Dimension;
     isPanelMaximized(): boolean;
     getPanelPosition(): Position;
@@ -20,6 +49,7 @@ declare class LayoutService implements ILayoutService, Pick<IWorkbenchLayoutServ
     getContainer(part: Parts): HTMLElement | undefined;
     getPart(key: Parts): Part;
     private hiddenParts;
+    private hasViews;
     setPartHidden(hidden: boolean, part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>): void;
     isVisible(part: Parts): boolean;
     getSideBarPosition(): Position;

package/dist/service-override/layout.js

@@ -1,4 +1,3 @@
-import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
 import '../missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { IWorkbenchLayoutService } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
@@ -9,13 +8,24 @@ import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { isAncestorUsingFlowTo } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IPaneCompositePartService } from '../vscode/vs/workbench/services/panecomposite/browser/panecomposite.js';
+import { IViewDescriptorService } from '../vscode/vs/workbench/common/views.js';
 import { isChrome, isFirefox, isSafari, isWindows, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-let LayoutService = class LayoutService {
-    constructor(container, paneCompositeService) {
+import { IEditorGroupsService } from '../vscode/vs/workbench/services/editor/common/editorGroupsService.js';
+import { IStatusbarService } from '../vscode/vs/workbench/services/statusbar/browser/statusbar.js';
+import { onRenderWorkbench } from '../lifecycle.js';
+class LayoutService {
+    constructor(container) {
         this.container = container;
-        this.paneCompositeService = paneCompositeService;
         this.onDidChangeFullscreen = Event.None;
+        this.onDidChangeZenMode = Event.None;
+        this.onDidChangeWindowMaximized = Event.None;
+        this.onDidChangeCenteredLayout = Event.None;
+        this.onDidChangePanelPosition = Event.None;
+        this.onDidChangePanelAlignment = Event.None;
+        this.onDidChangeNotificationsVisibility = Event.None;
+        this.openedDefaultEditors = false;
+        this.whenRestored = Promise.resolve();
         this.parts = new Map();
         this.hiddenParts = new Set();
         this._onDidChangePartVisibility = new Emitter();
@@ -26,6 +36,79 @@ let LayoutService = class LayoutService {
         window.addEventListener('resize', () => this.layout());
         this.layout();
     }
+    init(accessor) {
+        this.editorGroupService = accessor.get(IEditorGroupsService);
+        this.paneCompositeService = accessor.get(IPaneCompositePartService);
+        this.statusBarService = accessor.get(IStatusbarService);
+        this.viewDescriptorService = accessor.get(IViewDescriptorService);
+    }
+    focusPart(part) {
+        switch (part) {
+            case "workbench.parts.editor" :
+                this.editorGroupService.activeGroup.focus();
+                break;
+            case "workbench.parts.panel" : {
+                const activePanel = this.paneCompositeService.getActivePaneComposite(1 );
+                activePanel?.focus();
+                break;
+            }
+            case "workbench.parts.sidebar" : {
+                const activeViewlet = this.paneCompositeService.getActivePaneComposite(0 );
+                activeViewlet?.focus();
+                break;
+            }
+            case "workbench.parts.activitybar" :
+                this.getPart("workbench.parts.activitybar" ).focus();
+                break;
+            case "workbench.parts.statusbar" :
+                this.statusBarService.focus();
+                break;
+            default: {
+                const container = this.getContainer(part);
+                container?.focus();
+            }
+        }
+    }
+    getDimension(part) {
+        return this.getPart(part).dimension;
+    }
+    toggleMaximizedPanel() {
+    }
+    hasWindowBorder() {
+        return false;
+    }
+    getWindowBorderWidth() {
+        return 0;
+    }
+    getWindowBorderRadius() {
+        return undefined;
+    }
+    toggleMenuBar() {
+    }
+    setPanelPosition() {
+    }
+    getPanelAlignment() {
+        return 'left';
+    }
+    setPanelAlignment() {
+    }
+    toggleZenMode() {
+    }
+    isEditorLayoutCentered() {
+        return false;
+    }
+    centerEditorLayout() {
+    }
+    resizePart() {
+    }
+    isWindowMaximized() {
+        return false;
+    }
+    updateWindowMaximizedState() {
+    }
+    getVisibleNeighborPart() {
+        return undefined;
+    }
     getMaximumEditorDimensions() {
         return new dom.Dimension(Infinity, Infinity);
     }
@@ -56,6 +139,17 @@ let LayoutService = class LayoutService {
         }
         return part;
     }
+    hasViews(id) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
+        if (viewContainer == null) {
+            return false;
+        }
+        const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+        if (viewContainerModel == null) {
+            return false;
+        }
+        return viewContainerModel.activeViewDescriptors.length >= 1;
+    }
     setPartHidden(hidden, part) {
         if (hidden) {
             this.hiddenParts.add(part);
@@ -71,18 +165,24 @@ let LayoutService = class LayoutService {
         }[part];
         if (location != null) {
             const paneComposite = this.paneCompositeService.getActivePaneComposite(location);
-            if (paneComposite != null) {
-                if (hidden) {
-                    this.paneCompositeService.hideActivePaneComposite(location);
+            if (paneComposite != null && hidden) {
+                this.paneCompositeService.hideActivePaneComposite(location);
+            }
+            else if (paneComposite == null && !hidden) {
+                let panelToOpen = this.paneCompositeService.getLastActivePaneCompositeId(location);
+                if (panelToOpen == null || !this.hasViews(panelToOpen)) {
+                    panelToOpen = this.viewDescriptorService
+                        .getViewContainersByLocation(1 )
+                        .find(viewContainer => this.hasViews(viewContainer.id))?.id;
+                }
+                if (panelToOpen != null) {
+                    void this.paneCompositeService.openPaneComposite(panelToOpen, 1 , true);
                 }
             }
             if (this.paneCompositeService.getPartByLocation != null) {
                 this.paneCompositeService.getPartByLocation(location).setVisible(!hidden);
             }
         }
-        setTimeout(() => {
-            this.setPartHidden(false, part);
-        });
     }
     isVisible(part) {
         return !( this.hiddenParts.has(part));
@@ -107,10 +207,13 @@ let LayoutService = class LayoutService {
     focus() {
         StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor()?.focus();
     }
-};
-LayoutService = __decorate([
-    ( __param(1, IPaneCompositePartService))
-], LayoutService);
+}
+onRenderWorkbench((accessor) => {
+    const layoutService = accessor.get(ILayoutService);
+    if (layoutService instanceof LayoutService) {
+        layoutService.init(accessor);
+    }
+});
 function getServiceOverride(container = document.body) {
     const platformClass = isWindows ? 'windows' : isLinux ? 'linux' : 'mac';
     const workbenchClasses = coalesce([

package/dist/service-override/notifications.js

@@ -11,7 +11,7 @@ import { NotificationsAlerts } from '../vscode/vs/workbench/browser/parts/notifi
 import { NotificationsTelemetry } from '../vscode/vs/workbench/browser/parts/notifications/notificationsTelemetry.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 import getServiceOverride$1 from './layout.js';
-import { onRenderWorkbench } from '../services.js';
+import { onRenderWorkbench } from '../lifecycle.js';
 onRenderWorkbench(async (accessor) => {
     const container = accessor.get(ILayoutService).container;
     const model = accessor.get(INotificationService).model;

package/dist/service-override/snippets.js

@@ -5,7 +5,7 @@ import { ISnippetsService } from '../vscode/vs/workbench/contrib/snippets/browse
 import { SnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippetsService.js';
 import { ILifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
 import getServiceOverride$1 from './files.js';
-import { registerServiceInitializeParticipant } from '../services.js';
+import { registerServiceInitializeParticipant } from '../lifecycle.js';
 import '../vscode/vs/workbench/contrib/snippets/browser/snippets.contribution.js';
 registerServiceInitializeParticipant(async (accessor) => {
     void accessor.get(ILifecycleService).when(2 ).then(() => {

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

@@ -1,6 +1,12 @@
 import { IDisposable } from '../vscode/vs/base/common/lifecycle.js';
-import { IStorageItemsChangeEvent } from '../vscode/vs/base/parts/storage/common/storage.js';
+import { IStorageItemsChangeEvent, IStorage } from '../vscode/vs/base/parts/storage/common/storage.js';
 import { IEditorOverrideServices } from '../vscode/vs/editor/standalone/browser/standaloneServices.js';
+import { AbstractStorageService, StorageScope as StorageScope$1 } from '../vscode/vs/platform/storage/common/storage.js';
+import { IUserDataProfile } from '../vscode/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IAnyWorkspaceIdentifier } from '../vscode/vs/platform/workspace/common/workspace.js';
+import { BrowserStorageService } from '../vscode/vs/workbench/services/storage/browser/storageService.js';
+import { ILogService } from '../vscode/vs/platform/log/common/log.js';
+import { IUserDataProfileService } from '../vscode/vs/workbench/services/userDataProfile/common/userDataProfile.js';
 
 declare enum StorageScope {
     APPLICATION = -1,
@@ -13,6 +19,22 @@ interface IStorageProvider {
     close?(scope: StorageScope): Promise<void>;
     onDidChange?(listener: (event: IStorageItemsChangeEvent) => void): IDisposable;
 }
-declare function getStorageServiceOverride(provider: IStorageProvider): IEditorOverrideServices;
+declare class ExternalStorageService extends AbstractStorageService {
+    protected readonly provider: IStorageProvider;
+    private readonly applicationStorage;
+    private readonly profileStorage;
+    private readonly workspaceStorage;
+    constructor(provider: IStorageProvider);
+    protected getStorage(scope: StorageScope$1): IStorage;
+    protected getLogDetails(scope: StorageScope$1): string | undefined;
+    protected doInitialize(): Promise<void>;
+    protected switchToProfile(): Promise<void>;
+    protected switchToWorkspace(): Promise<void>;
+    hasScope(_scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
+}
+declare class InjectedBrowserStorageService extends BrowserStorageService {
+    constructor(userDataProfileService: IUserDataProfileService, logService: ILogService);
+}
+declare function getStorageServiceOverride(provider?: IStorageProvider): IEditorOverrideServices;
 
-export { IStorageItemsChangeEvent, IStorageProvider, StorageScope, getStorageServiceOverride as default };
+export { ExternalStorageService, IStorageItemsChangeEvent, IStorageProvider, InjectedBrowserStorageService, StorageScope, getStorageServiceOverride as default };

package/dist/service-override/storage.js

@@ -1,8 +1,13 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Storage } from 'monaco-editor/esm/vs/base/parts/storage/common/storage.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { IStorageService, AbstractStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { registerServiceInitializePreParticipant } from '../services.js';
+import { AbstractStorageService, IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { BrowserStorageService } from '../vscode/vs/workbench/services/storage/browser/storageService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUserDataProfileService } from '../vscode/vs/workbench/services/userDataProfile/common/userDataProfile.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { registerServiceInitializePreParticipant } from '../lifecycle.js';
 var StorageScope;
 ( (function(StorageScope) {
     StorageScope[StorageScope["APPLICATION"] = -1] = "APPLICATION";
@@ -85,9 +90,27 @@ class ExternalStorageService extends AbstractStorageService {
 registerServiceInitializePreParticipant(async (accessor) => {
     await accessor.get(IStorageService).initialize();
 });
+let InjectedBrowserStorageService = class InjectedBrowserStorageService extends BrowserStorageService {
+    constructor(userDataProfileService, logService) {
+        super({
+            id: generateUuid()
+        }, userDataProfileService, logService);
+    }
+};
+InjectedBrowserStorageService = __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, ILogService))
+], InjectedBrowserStorageService);
 function getStorageServiceOverride(provider) {
-    return {
-        [( IStorageService.toString())]: new SyncDescriptor(ExternalStorageService, [provider], true)
-    };
+    if (provider != null) {
+        return {
+            [( IStorageService.toString())]: new SyncDescriptor(ExternalStorageService, [provider], true)
+        };
+    }
+    else {
+        return {
+            [( IStorageService.toString())]: new SyncDescriptor(InjectedBrowserStorageService, [], true)
+        };
+    }
 }
-export { StorageScope, getStorageServiceOverride as default };
+export { ExternalStorageService, InjectedBrowserStorageService, StorageScope, getStorageServiceOverride as default };

package/dist/service-override/textmate.js

@@ -10,7 +10,7 @@ import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform
 import { ILifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import getServiceOverride$1 from './files.js';
-import { registerServiceInitializeParticipant } from '../services.js';
+import { registerServiceInitializeParticipant } from '../lifecycle.js';
 import { registerAssets } from '../assets.js';
 const _onigWasm = new URL('vscode-oniguruma/release/onig.wasm', import.meta.url).href;
 registerAssets({

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

@@ -8,14 +8,21 @@ import { IDisposable } from '../vscode/vs/base/common/lifecycle.js';
 export { IReference } from '../vscode/vs/base/common/lifecycle.js';
 export { HoverService } from '../vscode/vs/workbench/services/hover/browser/hoverService.js';
 export { PanelPart } from '../vscode/vs/workbench/browser/parts/panel/panelPart.js';
+import { Part } from '../vscode/vs/workbench/browser/part.js';
 export { IEditorOptions } from '../vscode/vs/platform/editor/common/editor.js';
 import { Codicon } from '../vscode/vs/base/common/codicons.js';
 import { IEditorCloseHandler, EditorInput } from '../vscode/vs/workbench/common/editor/editorInput.js';
 export { IResolvedTextEditorModel } from '../vscode/vs/editor/common/services/resolverService.js';
 export { StatusbarPart } from '../vscode/vs/workbench/browser/parts/statusbar/statusbarPart.js';
+import { Parts } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 export { ConfirmResult } from '../vscode/vs/platform/dialogs/common/dialogs.js';
 import { OpenEditor } from '../dist/types/src/service-override/tools/editor.js';
 
+declare function renderPart(partContainer: HTMLElement, part: Part): void;
+declare function attachPart(part: Parts, container: HTMLElement): IDisposable;
+declare function onPartVisibilityChange(part: Parts, listener: (visible: boolean) => void): IDisposable;
+declare function isPartVisibile(part: Parts): boolean;
+declare function setPartVisibility(part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>, visible: boolean): void;
 declare function renderActivitybarPar(container: HTMLElement): IDisposable;
 declare function renderSidebarPart(container: HTMLElement): IDisposable;
 declare function renderPanelPart(container: HTMLElement): IDisposable;
@@ -65,4 +72,4 @@ declare function registerCustomView(options: CustomViewOption): IDisposable;
 declare function isEditorPartVisible(): boolean;
 declare function getServiceOverride(openEditorFallback?: OpenEditor, _webviewIframeAlternateDomains?: string): IEditorOverrideServices;
 
-export { CustomViewOption, EditorPanelOption, IEditorCloseHandler, OpenEditor, ViewContainerLocation, getServiceOverride as default, isEditorPartVisible, registerCustomView, registerEditorPane, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderSidebarPart, renderStatusBarPart };
+export { CustomViewOption, EditorPanelOption, IEditorCloseHandler, OpenEditor, Parts, ViewContainerLocation, attachPart, getServiceOverride as default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditorPane, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility };

package/dist/service-override/views.js

@@ -84,7 +84,8 @@ import { IWebviewWorkbenchService, WebviewEditorService } from '../vscode/vs/wor
 import { IWebviewService } from '../vscode/vs/workbench/contrib/webview/browser/webview.js';
 import { IWebviewViewService, WebviewViewService } from '../vscode/vs/workbench/contrib/webviewView/browser/webviewViewService.js';
 import { ILifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
-import { positionToString } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService, positionToString } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
+export { Parts } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 import { EditorPaneDescriptor } from '../vscode/vs/workbench/browser/editor.js';
 import { EditorPane } from '../vscode/vs/workbench/browser/parts/editor/editorPane.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
@@ -98,7 +99,7 @@ import getServiceOverride$1 from './layout.js';
 import getServiceOverride$3 from './quickaccess.js';
 import { changeUrlDomain } from './tools/url.js';
 import { registerAssets } from '../assets.js';
-import { registerServiceInitializePostParticipant } from '../services.js';
+import { registerServiceInitializePostParticipant } from '../lifecycle.js';
 function createPart(id, role, classes) {
     const part = document.createElement(role === 'status' ? 'footer'  : 'div');
     part.classList.add('part', ...classes);
@@ -131,7 +132,7 @@ function renderPart(partContainer, part) {
 function getPart(part) {
     return StandaloneServices.get(ILayoutService).getPart(part);
 }
-function attachPart(part, container) {
+function _attachPart(part, container) {
     container.append(part.getContainer());
     const observer = new ResizeObserver(() => layoutPart(part));
     observer.observe(container);
@@ -141,23 +142,35 @@ function attachPart(part, container) {
         }
     };
 }
+function attachPart(part, container) {
+    return _attachPart(getPart(part), container);
+}
+function onPartVisibilityChange(part, listener) {
+    return getPart(part).onDidVisibilityChange(listener);
+}
+function isPartVisibile(part) {
+    return StandaloneServices.get(IWorkbenchLayoutService).isVisible(part);
+}
+function setPartVisibility(part, visible) {
+    StandaloneServices.get(IWorkbenchLayoutService).setPartHidden(!visible, part);
+}
 function renderActivitybarPar(container) {
-    return attachPart(getPart("workbench.parts.activitybar" ), container);
+    return attachPart("workbench.parts.activitybar" , container);
 }
 function renderSidebarPart(container) {
-    return attachPart(getPart("workbench.parts.sidebar" ), container);
+    return attachPart("workbench.parts.sidebar" , container);
 }
 function renderPanelPart(container) {
-    return attachPart(getPart("workbench.parts.panel" ), container);
+    return attachPart("workbench.parts.panel" , container);
 }
 function renderAuxiliaryPart(container) {
-    return attachPart(getPart("workbench.parts.auxiliarybar" ), container);
+    return attachPart("workbench.parts.auxiliarybar" , container);
 }
 function renderEditorPart(container) {
-    return attachPart(getPart("workbench.parts.editor" ), container);
+    return attachPart("workbench.parts.editor" , container);
 }
 function renderStatusBarPart(container) {
-    return attachPart(getPart("workbench.parts.statusbar" ), container);
+    return attachPart("workbench.parts.statusbar" , container);
 }
 function registerEditorPane(options) {
     let CustomEditorPane = class CustomEditorPane extends EditorPane {
@@ -439,4 +452,4 @@ function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains)
         [( IWebviewWorkbenchService.toString())]: new SyncDescriptor(WebviewEditorService, [], true)
     };
 }
-export { ActivityService, HoverService, StatusbarPart, getServiceOverride as default, isEditorPartVisible, registerCustomView, registerEditorPane, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderSidebarPart, renderStatusBarPart };
+export { ActivityService, HoverService, StatusbarPart, attachPart, getServiceOverride as default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditorPane, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility };

package/dist/services.d.ts

@@ -1,4 +1,3 @@
-import { Event } from './vscode/vs/base/common/event.js';
 export { default as Severity } from './vscode/vs/base/common/severity.js';
 export { IConfigurationChangeEvent, IConfigurationService } from './vscode/vs/platform/configuration/common/configuration.js';
 export { ITextModelContentProvider, ITextModelService } from './vscode/vs/editor/common/services/resolverService.js';
@@ -6,7 +5,7 @@ export { IColorTheme, IThemeService } from './vscode/vs/platform/theme/common/th
 export { IStorageService, StorageScope, StorageTarget } from './vscode/vs/platform/storage/common/storage.js';
 import { IEditorOverrideServices } from './vscode/vs/editor/standalone/browser/standaloneServices.js';
 export { StandaloneServices } from './vscode/vs/editor/standalone/browser/standaloneServices.js';
-import { ServicesAccessor, ServiceIdentifier } from './vscode/vs/platform/instantiation/common/instantiation.js';
+import { ServiceIdentifier } from './vscode/vs/platform/instantiation/common/instantiation.js';
 export { IInstantiationService } from './vscode/vs/platform/instantiation/common/instantiation.js';
 export { IAction } from './vscode/vs/base/common/actions.js';
 export { SyncDescriptor } from './vscode/vs/platform/instantiation/common/descriptors.js';
@@ -64,14 +63,7 @@ export { IHoverService } from './vscode/vs/workbench/services/hover/browser/hove
 export { IExplorerService } from './vscode/vs/workbench/contrib/files/browser/files.js';
 export { IStatusbarService } from './vscode/vs/workbench/services/statusbar/browser/statusbar.js';
 
-interface ServiceInitializeParticipant {
-    (accessor: ServicesAccessor): Promise<void>;
-}
-declare function registerServiceInitializePreParticipant(participant: ServiceInitializeParticipant): void;
-declare function registerServiceInitializeParticipant(participant: ServiceInitializeParticipant): void;
-declare function registerServiceInitializePostParticipant(participant: ServiceInitializeParticipant): void;
-declare const onRenderWorkbench: Event<ServicesAccessor>;
-declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;
 declare function initialize(overrides: IEditorOverrideServices): Promise<void>;
+declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;
 
-export { getService, initialize, onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant };
+export { getService, initialize };

package/dist/services.js

@@ -1,17 +1,13 @@
 export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.js';
 export { StorageScope, StorageTarget } from './vscode/vs/platform/storage/common/storage.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from './vscode/vs/workbench/common/contributions.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { ILifecycleService } from './vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
-import { Barrier, RunOnceScheduler, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import getServiceOverride from './service-override/layout.js';
 import getServiceOverride$1 from './service-override/environment.js';
 import getServiceOverride$2 from './service-override/extensions.js';
 import getServiceOverride$3 from './service-override/files.js';
 import getServiceOverride$4 from './service-override/quickaccess.js';
+import { startup, serviceInitializedBarrier } from './lifecycle.js';
 export { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 export { INotificationService, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationPriority, NotificationsFilter } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -68,19 +64,7 @@ export { IHoverService } from './vscode/vs/workbench/services/hover/browser/hove
 export { IExplorerService } from './vscode/vs/workbench/contrib/files/browser/files.js';
 export { IStatusbarService } from './vscode/vs/workbench/services/statusbar/browser/statusbar.js';
 export { IDialogService } from './vscode/vs/platform/dialogs/common/dialogs.js';
-const serviceInitializePreParticipants = [];
-const serviceInitializeParticipants = [];
-const serviceInitializePostParticipants = [];
-function registerServiceInitializePreParticipant(participant) {
-    serviceInitializePreParticipants.push(participant);
-}
-function registerServiceInitializeParticipant(participant) {
-    serviceInitializeParticipants.push(participant);
-}
-function registerServiceInitializePostParticipant(participant) {
-    serviceInitializePostParticipants.push(participant);
-}
-async function initServices(overrides) {
+async function initialize(overrides) {
     const instantiationService = StandaloneServices.initialize({
         ...getServiceOverride(),
         ...getServiceOverride$1(),
@@ -89,40 +73,10 @@ async function initServices(overrides) {
         ...getServiceOverride$4(),
         ...overrides
     });
-    await instantiationService.invokeFunction(async (accessor) => {
-        await Promise.all(( serviceInitializePreParticipants.map(participant => participant(accessor))));
-    });
-    await instantiationService.invokeFunction(async (accessor) => {
-        const lifecycleService = accessor.get(ILifecycleService);
-        await Promise.all(( serviceInitializeParticipants.map(participant => participant(accessor))));
-        lifecycleService.phase = 2 ;
-    });
-    await instantiationService.invokeFunction(async (accessor) => {
-        await Promise.all(( serviceInitializePostParticipants.map(participant => participant(accessor))));
-    });
-    return instantiationService;
+    await startup(instantiationService);
 }
-const renderWorkbenchEmitter = new Emitter();
-const onRenderWorkbench = renderWorkbenchEmitter.event;
-const serviceInitializedBarrier = new Barrier();
 async function getService(identifier) {
     await serviceInitializedBarrier.wait();
     return StandaloneServices.get(identifier);
 }
-async function initialize(overrides) {
-    const instantiationService = await initServices(overrides);
-    serviceInitializedBarrier.open();
-    instantiationService.invokeFunction(accessor => {
-        const lifecycleService = accessor.get(ILifecycleService);
-        ( Registry.as(Extensions.Workbench)).start(accessor);
-        renderWorkbenchEmitter.fire(accessor);
-        lifecycleService.phase = 3 ;
-        const eventuallyPhaseScheduler = new RunOnceScheduler(() => {
-            runWhenIdle(() => {
-                lifecycleService.phase = 4 ;
-            }, 2500);
-        }, 2500);
-        eventuallyPhaseScheduler.schedule();
-    });
-}
-export { getService, initialize, onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant };
+export { getService, initialize };