@codingame/monaco-vscode-api 3.0.0 → 3.1.1

package/vscode/src/vs/workbench/browser/parts/globalCompositeBar.js

@@ -1,45 +1,60 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from '../../../nls.js';
 import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar.js';
-import { GLOBAL_ACTIVITY_ID } from '../../common/activity.js';
+import { GLOBAL_ACTIVITY_ID, ACCOUNTS_ACTIVITY_ID } from '../../common/activity.js';
 import { NumberBadge, IActivityService } from '../../services/activity/common/activity.js';
 import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
 import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { IThemeService } from '../../../platform/theme/common/themeService.js';
+import { IStorageService } from '../../../platform/storage/common/storage.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
 import { CompositeBarAction, CompositeBarActionViewItem } from './compositeBarActions.js';
 import { Codicon } from '../../../base/common/codicons.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
 import { registerIcon } from '../../../platform/theme/common/iconRegistry.js';
-import { Action } from '../../../base/common/actions.js';
+import { Action, toAction, Separator, SubmenuAction } from '../../../base/common/actions.js';
 import { MenuId, IMenuService } from '../../../platform/actions/common/actions.js';
-import { append, $, clearNode, hide, show, addDisposableListener, EventHelper, EventType, getWindow } from '../../../base/browser/dom.js';
+import { runWhenWindowIdle, getWindow, append, $, clearNode, hide, show, addDisposableListener, EventHelper, EventType } from '../../../base/browser/dom.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
 import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
 import { EventType as EventType$1 } from '../../../base/browser/touch.js';
+import { Lazy } from '../../../base/common/lazy.js';
 import { createAndFillInActionBarActions } from '../../../platform/actions/browser/menuEntryActionViewItem.js';
 import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
 import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.js';
 import { IContextMenuService } from '../../../platform/contextview/browser/contextView.js';
 import { IKeybindingService } from '../../../platform/keybinding/common/keybinding.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { IProductService } from '../../../platform/product/common/productService.js';
+import { ISecretStorageService } from '../../../platform/secrets/common/secrets.js';
+import { getCurrentAuthenticationSessionInfo } from '../../services/authentication/browser/authenticationService.js';
+import { IAuthenticationService } from '../../services/authentication/common/authentication.js';
 import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
 import { IHoverService } from '../../../platform/hover/browser/hover.js';
+import { ILifecycleService } from '../../services/lifecycle/common/lifecycle.js';
 import { IUserDataProfileService } from '../../services/userDataProfile/common/userDataProfile.js';
 import { DEFAULT_ICON } from '../../services/userDataProfile/common/userDataProfileIcons.js';
 import { isString } from '../../../base/common/types.js';
 import { ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND } from '../../common/theme.js';
+var GlobalCompositeBar_1;
 let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
+    static { GlobalCompositeBar_1 = this; }
+    static { this.ACCOUNTS_ACTION_INDEX = 0; }
     static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localizeWithPath(
         'vs/workbench/browser/parts/globalCompositeBar',
         'accountsViewBarIcon',
         "Accounts icon in the view bar."
     ))); }
-    constructor(contextMenuActionsProvider, colors, activityHoverOptions, configurationService, instantiationService) {
+    constructor(contextMenuActionsProvider, colors, activityHoverOptions, configurationService, instantiationService, storageService, extensionService) {
         super();
         this.contextMenuActionsProvider = contextMenuActionsProvider;
         this.colors = colors;
         this.activityHoverOptions = activityHoverOptions;
         this.instantiationService = instantiationService;
+        this.storageService = storageService;
+        this.extensionService = extensionService;
         this.globalActivityAction = this._register(( new Action(GLOBAL_ACTIVITY_ID)));
+        this.accountAction = this._register(( new Action(ACCOUNTS_ACTIVITY_ID)));
         this.element = document.createElement('div');
         const contextMenuAlignmentOptions = () => ({
             anchorAlignment: configurationService.getValue('workbench.sideBar.location') === 'left' ? 1  : 0 ,
@@ -50,13 +65,39 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
                 if (action.id === GLOBAL_ACTIVITY_ID) {
                     return this.instantiationService.createInstance(GlobalActivityActionViewItem, this.contextMenuActionsProvider, { colors: this.colors, hoverOptions: this.activityHoverOptions }, contextMenuAlignmentOptions);
                 }
+                if (action.id === ACCOUNTS_ACTIVITY_ID) {
+                    return this.instantiationService.createInstance(AccountsActivityActionViewItem, this.contextMenuActionsProvider, {
+                        colors: this.colors,
+                        hoverOptions: this.activityHoverOptions
+                    }, contextMenuAlignmentOptions, (actions) => {
+                        actions.unshift(...[
+                            toAction({ id: 'hideAccounts', label: ( localizeWithPath(
+                                'vs/workbench/browser/parts/globalCompositeBar',
+                                'hideAccounts',
+                                "Hide Accounts"
+                            )), run: () => this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, false, 0 , 0 ) }),
+                            ( new Separator())
+                        ]);
+                    });
+                }
                 throw new Error(`No view item for action '${action.id}'`);
             },
             orientation: 1 ,
             ariaLabel: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
             preventLoopNavigation: true
         })));
+        if (this.accountsVisibilityPreference) {
+            this.globalActivityActionBar.push(this.accountAction, { index: GlobalCompositeBar_1.ACCOUNTS_ACTION_INDEX });
+        }
         this.globalActivityActionBar.push(this.globalActivityAction);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+            if (!this._store.isDisposed) {
+                this._register(this.storageService.onDidChangeValue(0 , AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, this._store)(() => this.toggleAccountsActivity()));
+            }
+        });
     }
     create(parent) {
         parent.appendChild(this.element);
@@ -68,12 +109,31 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         return this.globalActivityActionBar.viewItems.length;
     }
     getContextMenuActions() {
-        return [];
+        return [toAction({ id: 'toggleAccountsVisibility', label: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'accounts', "Accounts")), checked: this.accountsVisibilityPreference, run: () => this.accountsVisibilityPreference = !this.accountsVisibilityPreference })];
+    }
+    toggleAccountsActivity() {
+        if (this.globalActivityActionBar.length() === 2 && this.accountsVisibilityPreference) {
+            return;
+        }
+        if (this.globalActivityActionBar.length() === 2) {
+            this.globalActivityActionBar.pull(GlobalCompositeBar_1.ACCOUNTS_ACTION_INDEX);
+        }
+        else {
+            this.globalActivityActionBar.push(this.accountAction, { index: GlobalCompositeBar_1.ACCOUNTS_ACTION_INDEX });
+        }
+    }
+    get accountsVisibilityPreference() {
+        return this.storageService.getBoolean(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, 0 , true);
+    }
+    set accountsVisibilityPreference(value) {
+        this.storageService.store(AccountsActivityActionViewItem.ACCOUNTS_VISIBILITY_PREFERENCE_KEY, value, 0 , 0 );
     }
 };
-GlobalCompositeBar = ( __decorate([
+GlobalCompositeBar = GlobalCompositeBar_1 = ( __decorate([
     ( __param(3, IConfigurationService)),
-    ( __param(4, IInstantiationService))
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IExtensionService))
 ], GlobalCompositeBar));
 let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionViewItem extends CompositeBarActionViewItem {
     constructor(menuId, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService) {
@@ -182,6 +242,231 @@ AbstractGlobalActivityActionViewItem = ( __decorate([
     ( __param(11, IKeybindingService)),
     ( __param(12, IActivityService))
 ], AbstractGlobalActivityActionViewItem));
+let AccountsActivityActionViewItem = class AccountsActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
+    static { this.ACCOUNTS_VISIBILITY_PREFERENCE_KEY = 'workbench.activity.showAccounts'; }
+    constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, fillContextMenuActions, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService) {
+        const action = instantiationService.createInstance(CompositeBarAction, {
+            id: ACCOUNTS_ACTIVITY_ID,
+            name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'accounts', "Accounts")),
+            classNames: ThemeIcon.asClassNameArray(GlobalCompositeBar.ACCOUNTS_ICON)
+        });
+        super(MenuId.AccountsContext, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
+        this.fillContextMenuActions = fillContextMenuActions;
+        this.lifecycleService = lifecycleService;
+        this.authenticationService = authenticationService;
+        this.productService = productService;
+        this.secretStorageService = secretStorageService;
+        this.logService = logService;
+        this.groupedAccounts = ( new Map());
+        this.problematicProviders = ( new Set());
+        this.initialized = false;
+        this.sessionFromEmbedder = ( new Lazy(
+            () => getCurrentAuthenticationSessionInfo(this.secretStorageService, this.productService)
+        ));
+        this._register(action);
+        this.registerListeners();
+        this.initialize();
+    }
+    registerListeners() {
+        this._register(this.authenticationService.onDidRegisterAuthenticationProvider(async (e) => {
+            await this.addAccountsFromProvider(e.id);
+        }));
+        this._register(this.authenticationService.onDidUnregisterAuthenticationProvider((e) => {
+            this.groupedAccounts.delete(e.id);
+            this.problematicProviders.delete(e.id);
+        }));
+        this._register(this.authenticationService.onDidChangeSessions(async (e) => {
+            for (const changed of [...(e.event.changed ?? []), ...(e.event.added ?? [])]) {
+                try {
+                    await this.addOrUpdateAccount(e.providerId, changed.account);
+                }
+                catch (e) {
+                    this.logService.error(e);
+                }
+            }
+            if (e.event.removed) {
+                for (const removed of e.event.removed) {
+                    this.removeAccount(e.providerId, removed.account);
+                }
+            }
+        }));
+    }
+    async initialize() {
+        await this.lifecycleService.when(3 );
+        if (this._store.isDisposed) {
+            return;
+        }
+        const disposable = this._register(runWhenWindowIdle(getWindow(this.element), async () => {
+            await this.doInitialize();
+            disposable.dispose();
+        }));
+    }
+    async doInitialize() {
+        const providerIds = this.authenticationService.getProviderIds();
+        const results = await Promise.allSettled(( providerIds.map(providerId => this.addAccountsFromProvider(providerId))));
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                this.logService.error(result.reason);
+            }
+        }
+        this.initialized = true;
+    }
+    async resolveMainMenuActions(accountsMenu, disposables) {
+        await super.resolveMainMenuActions(accountsMenu, disposables);
+        const providers = this.authenticationService.getProviderIds();
+        const otherCommands = accountsMenu.getActions();
+        let menus = [];
+        for (const providerId of providers) {
+            if (!this.initialized) {
+                const noAccountsAvailableAction = disposables.add(( new Action('noAccountsAvailable', ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'loading', "Loading...")), undefined, false)));
+                menus.push(noAccountsAvailableAction);
+                break;
+            }
+            const providerLabel = this.authenticationService.getLabel(providerId);
+            const accounts = this.groupedAccounts.get(providerId);
+            if (!accounts) {
+                if (( this.problematicProviders.has(providerId))) {
+                    const providerUnavailableAction = disposables.add(( new Action('providerUnavailable', ( localizeWithPath(
+                        'vs/workbench/browser/parts/globalCompositeBar',
+                        'authProviderUnavailable',
+                        '{0} is currently unavailable',
+                        providerLabel
+                    )), undefined, false)));
+                    menus.push(providerUnavailableAction);
+                    try {
+                        await this.addAccountsFromProvider(providerId);
+                    }
+                    catch (e) {
+                        this.logService.error(e);
+                    }
+                }
+                continue;
+            }
+            for (const account of accounts) {
+                const manageExtensionsAction = disposables.add(( new Action(`configureSessions${account.label}`, ( localizeWithPath(
+                    'vs/workbench/browser/parts/globalCompositeBar',
+                    'manageTrustedExtensions',
+                    "Manage Trusted Extensions"
+                )), undefined, true, () => {
+                    return this.authenticationService.manageTrustedExtensionsForAccount(providerId, account.label);
+                })));
+                const providerSubMenuActions = [manageExtensionsAction];
+                if (account.canSignOut) {
+                    const signOutAction = disposables.add(( new Action('signOut', ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'signOut', "Sign Out")), undefined, true, async () => {
+                        const allSessions = await this.authenticationService.getSessions(providerId);
+                        const sessionsForAccount = allSessions.filter(s => s.account.label === account.label);
+                        return await this.authenticationService.removeAccountSessions(providerId, account.label, sessionsForAccount);
+                    })));
+                    providerSubMenuActions.push(signOutAction);
+                }
+                const providerSubMenu = ( new SubmenuAction(
+                    'activitybar.submenu',
+                    `${account.label} (${providerLabel})`,
+                    providerSubMenuActions
+                ));
+                menus.push(providerSubMenu);
+            }
+        }
+        if (providers.length && !menus.length) {
+            const noAccountsAvailableAction = disposables.add(( new Action('noAccountsAvailable', ( localizeWithPath(
+                'vs/workbench/browser/parts/globalCompositeBar',
+                'noAccounts',
+                "You are not signed in to any accounts"
+            )), undefined, false)));
+            menus.push(noAccountsAvailableAction);
+        }
+        if (menus.length && otherCommands.length) {
+            menus.push(( new Separator()));
+        }
+        otherCommands.forEach((group, i) => {
+            const actions = group[1];
+            menus = menus.concat(actions);
+            if (i !== otherCommands.length - 1) {
+                menus.push(( new Separator()));
+            }
+        });
+        return menus;
+    }
+    async resolveContextMenuActions(disposables) {
+        const actions = await super.resolveContextMenuActions(disposables);
+        this.fillContextMenuActions(actions);
+        return actions;
+    }
+    async addOrUpdateAccount(providerId, account) {
+        let accounts = this.groupedAccounts.get(providerId);
+        if (!accounts) {
+            accounts = [];
+            this.groupedAccounts.set(providerId, accounts);
+        }
+        const sessionFromEmbedder = await this.sessionFromEmbedder.value;
+        let canSignOut = true;
+        if (sessionFromEmbedder
+            && !sessionFromEmbedder.canSignOut
+            && ( (await this.authenticationService.getSessions(providerId))
+                .some(s => s.id === sessionFromEmbedder.id
+                && s.account.id === account.id))) {
+            canSignOut = false;
+        }
+        const existingAccount = accounts.find(a => a.label === account.label);
+        if (existingAccount) {
+            if (!canSignOut) {
+                existingAccount.canSignOut = canSignOut;
+            }
+        }
+        else {
+            accounts.push({ ...account, canSignOut });
+        }
+    }
+    removeAccount(providerId, account) {
+        const accounts = this.groupedAccounts.get(providerId);
+        if (!accounts) {
+            return;
+        }
+        const index = accounts.findIndex(a => a.id === account.id);
+        if (index === -1) {
+            return;
+        }
+        accounts.splice(index, 1);
+        if (accounts.length === 0) {
+            this.groupedAccounts.delete(providerId);
+        }
+    }
+    async addAccountsFromProvider(providerId) {
+        try {
+            const sessions = await this.authenticationService.getSessions(providerId);
+            this.problematicProviders.delete(providerId);
+            for (const session of sessions) {
+                try {
+                    await this.addOrUpdateAccount(providerId, session.account);
+                }
+                catch (e) {
+                    this.logService.error(e);
+                }
+            }
+        }
+        catch (e) {
+            this.logService.error(e);
+            this.problematicProviders.add(providerId);
+        }
+    }
+};
+AccountsActivityActionViewItem = ( __decorate([
+    ( __param(4, IThemeService)),
+    ( __param(5, ILifecycleService)),
+    ( __param(6, IHoverService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IAuthenticationService)),
+    ( __param(11, IWorkbenchEnvironmentService)),
+    ( __param(12, IProductService)),
+    ( __param(13, IConfigurationService)),
+    ( __param(14, IKeybindingService)),
+    ( __param(15, ISecretStorageService)),
+    ( __param(16, ILogService)),
+    ( __param(17, IActivityService)),
+    ( __param(18, IInstantiationService))
+], AccountsActivityActionViewItem));
 let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
     constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
         const action = instantiationService.createInstance(CompositeBarAction, {
@@ -251,6 +536,36 @@ GlobalActivityActionViewItem = ( __decorate([
     ( __param(12, IInstantiationService)),
     ( __param(13, IActivityService))
 ], GlobalActivityActionViewItem));
+let SimpleAccountActivityActionViewItem = class SimpleAccountActivityActionViewItem extends AccountsActivityActionViewItem {
+    constructor(hoverOptions, options, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService) {
+        super(() => [], {
+            ...options,
+            colors: theme => ({
+                badgeBackground: theme.getColor(ACTIVITY_BAR_BADGE_BACKGROUND),
+                badgeForeground: theme.getColor(ACTIVITY_BAR_BADGE_FOREGROUND),
+            }),
+            hoverOptions,
+            compact: true,
+        }, () => undefined, actions => actions, themeService, lifecycleService, hoverService, contextMenuService, menuService, contextKeyService, authenticationService, environmentService, productService, configurationService, keybindingService, secretStorageService, logService, activityService, instantiationService);
+    }
+};
+SimpleAccountActivityActionViewItem = ( __decorate([
+    ( __param(2, IThemeService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, IHoverService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IMenuService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IAuthenticationService)),
+    ( __param(9, IWorkbenchEnvironmentService)),
+    ( __param(10, IProductService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IKeybindingService)),
+    ( __param(13, ISecretStorageService)),
+    ( __param(14, ILogService)),
+    ( __param(15, IActivityService)),
+    ( __param(16, IInstantiationService))
+], SimpleAccountActivityActionViewItem));
 let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewItem extends GlobalActivityActionViewItem {
     constructor(hoverOptions, options, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
         super(() => [], {
@@ -277,4 +592,4 @@ SimpleGlobalActivityActionViewItem = ( __decorate([
     ( __param(11, IInstantiationService)),
     ( __param(12, IActivityService))
 ], SimpleGlobalActivityActionViewItem));
-export { GlobalActivityActionViewItem, GlobalCompositeBar, SimpleGlobalActivityActionViewItem };
+export { AccountsActivityActionViewItem, GlobalActivityActionViewItem, GlobalCompositeBar, SimpleAccountActivityActionViewItem, SimpleGlobalActivityActionViewItem };

package/vscode/src/vs/workbench/common/contributions.d.ts

@@ -3,5 +3,48 @@
  */
 interface IWorkbenchContribution {
 }
+declare const enum WorkbenchPhase {
+    /**
+     * The first phase signals that we are about to startup getting ready.
+     *
+     * Note: doing work in this phase blocks an editor from showing to
+     * the user, so please rather consider to use the other types, preferable
+     * `Lazy` to only instantiate the contribution when really needed.
+     */
+    BlockStartup = 1,
+    /**
+     * Services are ready and the window is about to restore its UI state.
+     *
+     * Note: doing work in this phase blocks an editor from showing to
+     * the user, so please rather consider to use the other types, preferable
+     * `Lazy` to only instantiate the contribution when really needed.
+     */
+    BlockRestore = 2,
+    /**
+     * Views, panels and editors have restored. Editors are given a bit of
+     * time to restore their contents.
+     */
+    AfterRestored = 3,
+    /**
+     * The last phase after views, panels and editors have restored and
+     * some time has passed (2-5 seconds).
+     */
+    Eventually = 4
+}
+/**
+ * A workbenchch contribution that will only be instantiated
+ * when calling `getWorkbenchContribution`.
+ */
+interface ILazyWorkbenchContributionInstantiation {
+    readonly lazy: true;
+}
+/**
+ * A workbench contribution that will be instantiated when the
+ * corresponding editor is being created.
+ */
+interface IOnEditorWorkbenchContributionInstantiation {
+    readonly editorTypeId: string;
+}
+type WorkbenchContributionInstantiation = WorkbenchPhase | ILazyWorkbenchContributionInstantiation | IOnEditorWorkbenchContributionInstantiation;
 
-export type { IWorkbenchContribution };
+export { type ILazyWorkbenchContributionInstantiation, type IOnEditorWorkbenchContributionInstantiation, type IWorkbenchContribution, type WorkbenchContributionInstantiation, WorkbenchPhase };

package/vscode/src/vs/workbench/common/contributions.js

@@ -12,6 +12,13 @@ var Extensions;
 ( (function(Extensions) {
     Extensions.Workbench = 'workbench.contributions.kind';
 })(Extensions || (Extensions = {})));
+var WorkbenchPhase;
+( (function(WorkbenchPhase) {
+    WorkbenchPhase[WorkbenchPhase["BlockStartup"] = 1] = "BlockStartup";
+    WorkbenchPhase[WorkbenchPhase["BlockRestore"] = 2] = "BlockRestore";
+    WorkbenchPhase[WorkbenchPhase["AfterRestored"] = 3] = "AfterRestored";
+    WorkbenchPhase[WorkbenchPhase["Eventually"] = 4] = "Eventually";
+})(WorkbenchPhase || (WorkbenchPhase = {})));
 function isOnEditorWorkbenchContributionInstantiation(obj) {
     const candidate = obj;
     return !!candidate && typeof candidate.editorTypeId === 'string';
@@ -225,4 +232,4 @@ class WorkbenchContributionsRegistry extends Disposable {
 const registerWorkbenchContribution2 = WorkbenchContributionsRegistry.INSTANCE.registerWorkbenchContribution2.bind(WorkbenchContributionsRegistry.INSTANCE);
 const getWorkbenchContribution = WorkbenchContributionsRegistry.INSTANCE.getWorkbenchContribution.bind(WorkbenchContributionsRegistry.INSTANCE);
 Registry.add(Extensions.Workbench, WorkbenchContributionsRegistry.INSTANCE);
-export { Extensions, WorkbenchContributionsRegistry, getWorkbenchContribution, registerWorkbenchContribution2 };
+export { Extensions, WorkbenchContributionsRegistry, WorkbenchPhase, getWorkbenchContribution, registerWorkbenchContribution2 };

package/vscode/src/vs/workbench/common/views.js

@@ -82,9 +82,7 @@ class ViewContainersRegistryImpl extends Disposable {
         return [...( this.viewContainers.keys())].filter(location => this.getViewContainers(location).filter(viewContainer => viewContainer?.id === container.id).length > 0)[0];
     }
     getDefaultViewContainer(location) {
-        const locationViewContainers = this.defaultViewContainers.filter(viewContainer => this.getViewContainerLocation(viewContainer) === location);
-        locationViewContainers.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-        return locationViewContainers[0];
+        return this.defaultViewContainers.find(viewContainer => this.getViewContainerLocation(viewContainer) === location);
     }
 }
 Registry.add(Extensions.ViewContainersRegistry, ( new ViewContainersRegistryImpl()));

package/vscode/src/vs/workbench/contrib/debug/browser/media/all.png.js

@@ -0,0 +1,11 @@
+var pngAssets = {
+  'vs/workbench/contrib/debug/browser/media/continue-tb.png': new URL('../../../../../../../../assets/continue-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/pause-tb.png': new URL('../../../../../../../../assets/pause-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/restart-tb.png': new URL('../../../../../../../../assets/restart-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/run-with-debugging-tb.png': new URL('../../../../../../../../assets/run-with-debugging-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/stepinto-tb.png': new URL('../../../../../../../../assets/stepinto-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/stepout-tb.png': new URL('../../../../../../../../assets/stepout-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/stepover-tb.png': new URL('../../../../../../../../assets/stepover-tb.png', import.meta.url).href,
+  'vs/workbench/contrib/debug/browser/media/stop-tb.png': new URL('../../../../../../../../assets/stop-tb.png', import.meta.url).href
+};
+export { pngAssets as default };

package/vscode/src/vs/workbench/contrib/files/browser/files.editorPane.contribution.js

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { sep } from '../../../../base/common/path.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { registerWorkbenchContribution2, Extensions } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { FILE_EDITOR_INPUT_ID, BINARY_TEXT_FILE_MODE } from '../common/files.js';
+import { TextFileEditorTracker } from './editors/textFileEditorTracker.js';
+import { TextFileSaveErrorHandler } from './editors/textFileSaveErrorHandler.js';
+import { FileEditorInput } from './editors/fileEditorInput.js';
+import { BinaryFileEditor } from './editors/binaryFileEditor.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { isWindows } from '../../../../base/common/platform.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { WorkspaceWatcher } from './workspaceWatcher.js';
+import { DirtyFilesIndicator } from '../common/dirtyFilesIndicator.js';
+import { FileEditorInputSerializer, FileEditorWorkingCopyEditorHandler } from './editors/fileEditorHandler.js';
+import { ModesRegistry } from '../../../../editor/common/languages/modesRegistry.js';
+import { TextFileEditor } from './editors/textFileEditor.js';
+import './files.fileEditorFactory.contribution.js';
+let FileUriLabelContribution = class FileUriLabelContribution {
+    static { this.ID = 'workbench.contrib.fileUriLabel'; }
+    constructor(labelService) {
+        labelService.registerFormatter({
+            scheme: Schemas.file,
+            formatting: {
+                label: '${authority}${path}',
+                separator: sep,
+                tildify: !isWindows,
+                normalizeDriveLetter: isWindows,
+                authorityPrefix: sep + sep,
+                workspaceSuffix: ''
+            }
+        });
+    }
+};
+FileUriLabelContribution = ( __decorate([
+    ( __param(0, ILabelService))
+], FileUriLabelContribution));
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(TextFileEditor, TextFileEditor.ID, ( localizeWithPath(
+    'vs/workbench/contrib/files/browser/files.editorPane.contribution',
+    'textFileEditor',
+    "Text File Editor"
+))), [
+    ( new SyncDescriptor(FileEditorInput))
+]);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(BinaryFileEditor, BinaryFileEditor.ID, ( localizeWithPath(
+    'vs/workbench/contrib/files/browser/files.editorPane.contribution',
+    'binaryFileEditor',
+    "Binary File Editor"
+))), [
+    ( new SyncDescriptor(FileEditorInput))
+]);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(FILE_EDITOR_INPUT_ID, FileEditorInputSerializer);
+registerWorkbenchContribution2(FileEditorWorkingCopyEditorHandler.ID, FileEditorWorkingCopyEditorHandler, 2 );
+registerWorkbenchContribution2(TextFileEditorTracker.ID, TextFileEditorTracker, 1 );
+registerWorkbenchContribution2(TextFileSaveErrorHandler.ID, TextFileSaveErrorHandler, 1 );
+registerWorkbenchContribution2(FileUriLabelContribution.ID, FileUriLabelContribution, 1 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkspaceWatcher, 3 );
+registerWorkbenchContribution2(DirtyFilesIndicator.ID, DirtyFilesIndicator, 1 );
+ModesRegistry.registerLanguage({
+    id: BINARY_TEXT_FILE_MODE,
+    aliases: ['Binary'],
+    mimetypes: ['text/x-code-binary']
+});