@codingame/monaco-vscode-api 2.2.2 → 3.1.0

package/vscode/src/vs/workbench/browser/parts/views/viewPaneContainer.js

@@ -433,11 +433,11 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
     getActionsContext() {
         return undefined;
     }
-    getActionViewItem(action) {
+    getActionViewItem(action, options) {
         if (this.isViewMergedWithContainer()) {
-            return this.paneItems[0].pane.getActionViewItem(action);
+            return this.paneItems[0].pane.getActionViewItem(action, options);
         }
-        return createActionViewItem(this.instantiationService, action);
+        return createActionViewItem(this.instantiationService, action, options);
     }
     focus() {
         let paneToFocus = undefined;
@@ -493,7 +493,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
     }
     addPanes(panes) {
         const wasMerged = this.isViewMergedWithContainer();
-        for (const { pane: pane, size, index, disposable } of panes) {
+        for (const { pane, size, index, disposable } of panes) {
             this.addPane(pane, size, disposable, index);
         }
         this.updateViewHeaders();

package/vscode/src/vs/workbench/browser/quickaccess.js

@@ -39,12 +39,19 @@ class EditorViewState {
             };
         }
     }
-    async restore() {
+    async restore(shouldCloseCurrEditor = false) {
         if (this._editorViewState) {
             const options = {
                 viewState: this._editorViewState.state,
                 preserveFocus: true
             };
+            if (shouldCloseCurrEditor) {
+                const activeEditorPane = this.editorService.activeEditorPane;
+                const currEditor = activeEditorPane?.input;
+                if (currEditor && currEditor !== this._editorViewState.editor && activeEditorPane?.group.isPinned(currEditor) !== true) {
+                    await activeEditorPane.group.closeEditor(currEditor);
+                }
+            }
             await this._editorViewState.group.openEditor(this._editorViewState.editor, options);
         }
     }

package/vscode/src/vs/workbench/browser/workbench.contribution.js

@@ -1,13 +1,15 @@
 import { Registry } from '../../platform/registry/common/platform.js';
 import { localizeWithPath } from '../../nls.js';
-import { Extensions as Extensions$2 } from '../../platform/configuration/common/configurationRegistry.js';
-import { isMacintosh, isWeb, isNative, isWindows, isLinux } from '../../base/common/platform.js';
-import { DynamicWorkbenchConfigurationWorkbenchContribution, workbenchConfigurationNodeBase, problemsConfigurationNodeBase, Extensions as Extensions$1 } from '../common/configuration.js';
+import { Extensions as Extensions$1 } from '../../platform/configuration/common/configurationRegistry.js';
+import { isMacintosh, isWeb, isWindows, isLinux } from '../../base/common/platform.js';
+import { ConfigurationMigrationWorkbenchContribution, DynamicWorkbenchSecurityConfiguration, workbenchConfigurationNodeBase, problemsConfigurationNodeBase, Extensions } from '../common/configuration.js';
 import { isStandalone } from '../../base/browser/browser.js';
-import { Extensions } from '../common/contributions.js';
-const registry = ( Registry.as(Extensions$2.Configuration));
+import { registerWorkbenchContribution2 } from '../common/contributions.js';
+import { defaultWindowTitle, defaultWindowTitleSeparator } from './parts/titlebar/windowTitle.js';
+const registry = ( Registry.as(Extensions$1.Configuration));
 (function registerConfiguration() {
-    ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DynamicWorkbenchConfigurationWorkbenchContribution, 2 );
+    registerWorkbenchContribution2(ConfigurationMigrationWorkbenchContribution.ID, ConfigurationMigrationWorkbenchContribution, 4 );
+    registerWorkbenchContribution2(DynamicWorkbenchSecurityConfiguration.ID, DynamicWorkbenchSecurityConfiguration, 3 );
     registry.registerConfiguration({
         ...workbenchConfigurationNodeBase,
         'properties': {
@@ -1251,6 +1253,16 @@ const registry = ( Registry.as(Extensions$2.Configuration));
             'focusedView',
             "`${focusedView}`: the name of the view that is currently focused."
         )),
+        ( localizeWithPath(
+            'vs/workbench/browser/workbench.contribution',
+            'activeRepositoryName',
+            "`${activeRepositoryName}`: the name of the active repository (e.g. vscode)."
+        )),
+        ( localizeWithPath(
+            'vs/workbench/browser/workbench.contribution',
+            'activeRepositoryBranchName',
+            "`${activeRepositoryBranchName}`: the name of the active branch in the active repository (e.g. main)."
+        )),
         ( localizeWithPath(
             'vs/workbench/browser/workbench.contribution',
             'separator',
@@ -1269,21 +1281,12 @@ const registry = ( Registry.as(Extensions$2.Configuration));
         'properties': {
             'window.title': {
                 'type': 'string',
-                'default': (() => {
-                    if (isMacintosh && isNative) {
-                        return '${activeEditorShort}${separator}${rootName}${separator}${profileName}';
-                    }
-                    const base = '${dirty}${activeEditorShort}${separator}${rootName}${separator}${profileName}${separator}${appName}';
-                    if (isWeb) {
-                        return base + '${separator}${remoteName}';
-                    }
-                    return base;
-                })(),
+                'default': defaultWindowTitle,
                 'markdownDescription': windowTitleDescription
             },
             'window.titleSeparator': {
                 'type': 'string',
-                'default': isMacintosh ? ' \u2014 ' : ' - ',
+                'default': defaultWindowTitleSeparator,
                 'markdownDescription': ( localizeWithPath(
                     'vs/workbench/browser/workbench.contribution',
                     "window.titleSeparator",
@@ -1517,7 +1520,6 @@ const registry = ( Registry.as(Extensions$2.Configuration));
             'problems.visibility': {
                 'type': 'boolean',
                 'default': true,
-                'tags': ['experimental'],
                 'description': ( localizeWithPath(
                     'vs/workbench/browser/workbench.contribution',
                     'problems.visibility',
@@ -1629,7 +1631,7 @@ const registry = ( Registry.as(Extensions$2.Configuration));
         }
     });
 })();
-( Registry.as(Extensions$1.ConfigurationMigration))
+( Registry.as(Extensions.ConfigurationMigration))
     .registerConfigurationMigrations([{
         key: 'workbench.activityBar.visible', migrateFn: (value) => {
             const result = [];
@@ -1642,7 +1644,7 @@ const registry = ( Registry.as(Extensions$2.Configuration));
             return result;
         }
     }]);
-( Registry.as(Extensions$1.ConfigurationMigration))
+( Registry.as(Extensions.ConfigurationMigration))
     .registerConfigurationMigrations([{
         key: 'workbench.editor.doubleClickTabToToggleEditorGroupSizes', migrateFn: (value) => {
             const results = [];

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

@@ -2,10 +2,14 @@ import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js'
 import { localizeWithPath } from '../../nls.js';
 import { Extensions as Extensions$1 } from '../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../platform/registry/common/platform.js';
+import { IWorkspaceContextService } from '../../platform/workspace/common/workspace.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.js';
 import { Disposable } from '../../base/common/lifecycle.js';
 import { Emitter } from '../../base/common/event.js';
 import { IRemoteAgentService } from '../services/remote/common/remoteAgentService.js';
 import { isWindows } from '../../base/common/platform.js';
+import { equals } from '../../base/common/objects.js';
+import { DeferredPromise } from '../../base/common/async.js';
 const applicationConfigurationNodeBase = ( Object.freeze({
     'id': 'application',
     'order': 100,
@@ -62,55 +66,154 @@ class ConfigurationMigrationRegistry {
 }
 const configurationMigrationRegistry = ( new ConfigurationMigrationRegistry());
 Registry.add(Extensions.ConfigurationMigration, configurationMigrationRegistry);
-let DynamicWorkbenchConfigurationWorkbenchContribution = class DynamicWorkbenchConfigurationWorkbenchContribution extends Disposable {
-    constructor(remoteAgentService) {
+let ConfigurationMigrationWorkbenchContribution = class ConfigurationMigrationWorkbenchContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.configurationMigration'; }
+    constructor(configurationService, workspaceService) {
         super();
-        (async () => {
-            if (!isWindows) {
-                const remoteEnvironment = await remoteAgentService.getEnvironment();
-                if (remoteEnvironment?.os !== 1 ) {
-                    return;
+        this.configurationService = configurationService;
+        this.workspaceService = workspaceService;
+        this._register(this.workspaceService.onDidChangeWorkspaceFolders(async (e) => {
+            for (const folder of e.added) {
+                await this.migrateConfigurationsForFolder(folder, configurationMigrationRegistry.migrations);
+            }
+        }));
+        this.migrateConfigurations(configurationMigrationRegistry.migrations);
+        this._register(configurationMigrationRegistry.onDidRegisterConfigurationMigration(migration => this.migrateConfigurations(migration)));
+    }
+    async migrateConfigurations(migrations) {
+        await this.migrateConfigurationsForFolder(undefined, migrations);
+        for (const folder of this.workspaceService.getWorkspace().folders) {
+            await this.migrateConfigurationsForFolder(folder, migrations);
+        }
+    }
+    async migrateConfigurationsForFolder(folder, migrations) {
+        await Promise.all([( migrations.map(
+            migration => this.migrateConfigurationsForFolderAndOverride(migration, folder?.uri)
+        ))]);
+    }
+    async migrateConfigurationsForFolderAndOverride(migration, resource) {
+        const inspectData = this.configurationService.inspect(migration.key, { resource });
+        const targetPairs = this.workspaceService.getWorkbenchState() === 3  ? [
+            ['user', 2 ],
+            ['userLocal', 3 ],
+            ['userRemote', 4 ],
+            ['workspace', 5 ],
+            ['workspaceFolder', 6 ],
+        ] : [
+            ['user', 2 ],
+            ['userLocal', 3 ],
+            ['userRemote', 4 ],
+            ['workspace', 5 ],
+        ];
+        for (const [dataKey, target] of targetPairs) {
+            const inspectValue = inspectData[dataKey];
+            if (!inspectValue) {
+                continue;
+            }
+            const migrationValues = [];
+            if (inspectValue.value !== undefined) {
+                const keyValuePairs = await this.runMigration(migration, dataKey, inspectValue.value, resource, undefined);
+                for (const keyValuePair of keyValuePairs ?? []) {
+                    migrationValues.push([keyValuePair, []]);
                 }
             }
-            const registry = ( Registry.as(Extensions$1.Configuration));
-            registry.registerConfiguration({
-                ...securityConfigurationNodeBase,
-                'properties': {
-                    'security.allowedUNCHosts': {
-                        'type': 'array',
-                        'items': {
-                            'type': 'string',
-                            'pattern': '^[^\\\\]+$',
-                            'patternErrorMessage': ( localizeWithPath(
-                                'vs/workbench/common/configuration',
-                                'security.allowedUNCHosts.patternErrorMessage',
-                                'UNC host names must not contain backslashes.'
-                            ))
-                        },
-                        'default': [],
-                        'markdownDescription': ( localizeWithPath(
+            for (const { identifiers, value } of inspectValue.overrides ?? []) {
+                if (value !== undefined) {
+                    const keyValuePairs = await this.runMigration(migration, dataKey, value, resource, identifiers);
+                    for (const keyValuePair of keyValuePairs ?? []) {
+                        migrationValues.push([keyValuePair, identifiers]);
+                    }
+                }
+            }
+            if (migrationValues.length) {
+                await Promise.allSettled(( migrationValues.map(
+                    async ([[key, value], overrideIdentifiers]) => this.configurationService.updateValue(key, value.value, { resource, overrideIdentifiers }, target)
+                )));
+            }
+        }
+    }
+    async runMigration(migration, dataKey, value, resource, overrideIdentifiers) {
+        const valueAccessor = (key) => {
+            const inspectData = this.configurationService.inspect(key, { resource });
+            const inspectValue = inspectData[dataKey];
+            if (!inspectValue) {
+                return undefined;
+            }
+            if (!overrideIdentifiers) {
+                return inspectValue.value;
+            }
+            return inspectValue.overrides?.find(({ identifiers }) => equals(identifiers, overrideIdentifiers))?.value;
+        };
+        const result = await migration.migrateFn(value, valueAccessor);
+        return Array.isArray(result) ? result : [[migration.key, result]];
+    }
+};
+ConfigurationMigrationWorkbenchContribution = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IWorkspaceContextService))
+], ConfigurationMigrationWorkbenchContribution));
+let DynamicWorkbenchSecurityConfiguration = class DynamicWorkbenchSecurityConfiguration extends Disposable {
+    static { this.ID = 'workbench.contrib.dynamicWorkbenchSecurityConfiguration'; }
+    constructor(remoteAgentService) {
+        super();
+        this.remoteAgentService = remoteAgentService;
+        this._ready = ( new DeferredPromise());
+        this.ready = this._ready.p;
+        this.create();
+    }
+    async create() {
+        try {
+            await this.doCreate();
+        }
+        finally {
+            this._ready.complete();
+        }
+    }
+    async doCreate() {
+        if (!isWindows) {
+            const remoteEnvironment = await this.remoteAgentService.getEnvironment();
+            if (remoteEnvironment?.os !== 1 ) {
+                return;
+            }
+        }
+        const registry = ( Registry.as(Extensions$1.Configuration));
+        registry.registerConfiguration({
+            ...securityConfigurationNodeBase,
+            'properties': {
+                'security.allowedUNCHosts': {
+                    'type': 'array',
+                    'items': {
+                        'type': 'string',
+                        'pattern': '^[^\\\\]+$',
+                        'patternErrorMessage': ( localizeWithPath(
                             'vs/workbench/common/configuration',
-                            'security.allowedUNCHosts',
-                            'A set of UNC host names (without leading or trailing backslash, for example `192.168.0.1` or `my-server`) to allow without user confirmation. If a UNC host is being accessed that is not allowed via this setting or has not been acknowledged via user confirmation, an error will occur and the operation stopped. A restart is required when changing this setting. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
-                        )),
-                        'scope': 2
+                            'security.allowedUNCHosts.patternErrorMessage',
+                            'UNC host names must not contain backslashes.'
+                        ))
                     },
-                    'security.restrictUNCAccess': {
-                        'type': 'boolean',
-                        'default': true,
-                        'markdownDescription': ( localizeWithPath(
-                            'vs/workbench/common/configuration',
-                            'security.restrictUNCAccess',
-                            'If enabled, only allows access to UNC host names that are allowed by the `#security.allowedUNCHosts#` setting or after user confirmation. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
-                        )),
-                        'scope': 2
-                    }
+                    'default': [],
+                    'markdownDescription': ( localizeWithPath(
+                        'vs/workbench/common/configuration',
+                        'security.allowedUNCHosts',
+                        'A set of UNC host names (without leading or trailing backslash, for example `192.168.0.1` or `my-server`) to allow without user confirmation. If a UNC host is being accessed that is not allowed via this setting or has not been acknowledged via user confirmation, an error will occur and the operation stopped. A restart is required when changing this setting. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
+                    )),
+                    'scope': 2
+                },
+                'security.restrictUNCAccess': {
+                    'type': 'boolean',
+                    'default': true,
+                    'markdownDescription': ( localizeWithPath(
+                        'vs/workbench/common/configuration',
+                        'security.restrictUNCAccess',
+                        'If enabled, only allows access to UNC host names that are allowed by the `#security.allowedUNCHosts#` setting or after user confirmation. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
+                    )),
+                    'scope': 2
                 }
-            });
-        })();
+            }
+        });
     }
 };
-DynamicWorkbenchConfigurationWorkbenchContribution = ( __decorate([
+DynamicWorkbenchSecurityConfiguration = ( __decorate([
     ( __param(0, IRemoteAgentService))
-], DynamicWorkbenchConfigurationWorkbenchContribution));
-export { DynamicWorkbenchConfigurationWorkbenchContribution, Extensions, applicationConfigurationNodeBase, problemsConfigurationNodeBase, securityConfigurationNodeBase, workbenchConfigurationNodeBase };
+], DynamicWorkbenchSecurityConfiguration));
+export { ConfigurationMigrationWorkbenchContribution, DynamicWorkbenchSecurityConfiguration, Extensions, applicationConfigurationNodeBase, problemsConfigurationNodeBase, securityConfigurationNodeBase, workbenchConfigurationNodeBase };

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

@@ -185,10 +185,10 @@ const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localiz
     'inZenMode',
     "Whether Zen mode is enabled"
 ))));
-const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localizeWithPath(
+const IsMainEditorCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localizeWithPath(
     'vs/workbench/common/contextkeys',
-    'isCenteredLayout',
-    "Whether centered layout is enabled"
+    'isMainEditorCenteredLayout',
+    "Whether centered layout is enabled for the main editor"
 ))));
 const SplitEditorsVertically = ( new RawContextKey('splitEditorsVertically', false, ( localizeWithPath(
     'vs/workbench/common/contextkeys',
@@ -473,4 +473,4 @@ function applyAvailableEditorIds(contextKey, editor, editorResolverService) {
         contextKey.set(editors.join(','));
     }
 }
-export { ActiveAuxiliaryContext, ActiveCompareEditorOriginalWriteableContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorReadonlyContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorPartMaximizedEditorGroupContext, EditorPartMultipleEditorGroupsContext, EditorTabsVisibleContext, EditorsVisibleContext, EmbedderIdentifierContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsAuxiliaryEditorPartContext, IsAuxiliaryWindowFocusedContext, IsCenteredLayoutContext, IsMainWindowFullscreenContext, MainEditorAreaVisibleContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, SplitEditorsVertically, StatusBarFocused, TemporaryWorkspaceContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, TitleBarStyleContext, TitleBarVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getVisbileViewContextKey };
+export { ActiveAuxiliaryContext, ActiveCompareEditorOriginalWriteableContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorReadonlyContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorPartMaximizedEditorGroupContext, EditorPartMultipleEditorGroupsContext, EditorTabsVisibleContext, EditorsVisibleContext, EmbedderIdentifierContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsAuxiliaryEditorPartContext, IsAuxiliaryWindowFocusedContext, IsMainEditorCenteredLayoutContext, IsMainWindowFullscreenContext, MainEditorAreaVisibleContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, SplitEditorsVertically, StatusBarFocused, TemporaryWorkspaceContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, TitleBarStyleContext, TitleBarVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getVisbileViewContextKey };

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

@@ -5,37 +5,135 @@ import { DeferredPromise, runWhenGlobalIdle } from '../../base/common/async.js';
 import { mark } from '../../base/common/performance.js';
 import { ILogService } from '../../platform/log/common/log.js';
 import { IEnvironmentService } from '../../platform/environment/common/environment.js';
+import { getOrSet } from '../../base/common/map.js';
+import { Disposable } from '../../base/common/lifecycle.js';
+import { IEditorPaneService } from '../services/editor/common/editorPaneService.js';
 var Extensions;
 ( (function(Extensions) {
     Extensions.Workbench = 'workbench.contributions.kind';
 })(Extensions || (Extensions = {})));
-class WorkbenchContributionsRegistry {
+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';
+}
+function toWorkbenchPhase(phase) {
+    switch (phase) {
+        case 3 :
+            return 3 ;
+        case 4 :
+            return 4 ;
+    }
+}
+function toLifecyclePhase(instantiation) {
+    switch (instantiation) {
+        case 1 :
+            return 1 ;
+        case 2 :
+            return 2 ;
+        case 3 :
+            return 3 ;
+        case 4 :
+            return 4 ;
+    }
+}
+class WorkbenchContributionsRegistry extends Disposable {
     constructor() {
-        this.contributions = ( new Map());
+        super(...arguments);
+        this.contributionsByPhase = ( new Map());
+        this.contributionsByEditor = ( new Map());
+        this.contributionsById = ( new Map());
+        this.instancesById = ( new Map());
+        this.timingsByPhase = ( new Map());
         this.pendingRestoredContributions = ( new DeferredPromise());
         this.whenRestored = this.pendingRestoredContributions.p;
     }
-    registerWorkbenchContribution(contribution, phase = 1 ) {
-        if (this.instantiationService && this.lifecycleService && this.logService && this.environmentService && this.lifecycleService.phase >= phase) {
-            this.safeCreateContribution(this.instantiationService, this.logService, this.environmentService, contribution, phase);
+    static { this.INSTANCE = ( new WorkbenchContributionsRegistry()); }
+    static { this.BLOCK_BEFORE_RESTORE_WARN_THRESHOLD = 20; }
+    static { this.BLOCK_AFTER_RESTORE_WARN_THRESHOLD = 100; }
+    get timings() { return this.timingsByPhase; }
+    registerWorkbenchContribution2(id, ctor, instantiation) {
+        const contribution = { id, ctor };
+        if (this.instantiationService && this.lifecycleService && this.logService && this.environmentService && this.editorPaneService &&
+            ((typeof instantiation === 'number' && this.lifecycleService.phase >= instantiation) ||
+                (typeof id === 'string' && isOnEditorWorkbenchContributionInstantiation(instantiation) && this.editorPaneService.didInstantiateEditorPane(instantiation.editorTypeId)))) {
+            this.safeCreateContribution(this.instantiationService, this.logService, this.environmentService, contribution, typeof instantiation === 'number' ? toLifecyclePhase(instantiation) : this.lifecycleService.phase);
         }
         else {
-            let contributions = this.contributions.get(phase);
-            if (!contributions) {
-                contributions = [];
-                this.contributions.set(phase, contributions);
+            if (typeof instantiation === 'number') {
+                getOrSet(this.contributionsByPhase, toLifecyclePhase(instantiation), []).push(contribution);
+            }
+            if (typeof id === 'string') {
+                if (!( this.contributionsById.has(id))) {
+                    this.contributionsById.set(id, contribution);
+                }
+                else {
+                    console.error(`IWorkbenchContributionsRegistry#registerWorkbenchContribution(): Can't register multiple contributions with same id '${id}'`);
+                }
+                if (isOnEditorWorkbenchContributionInstantiation(instantiation)) {
+                    getOrSet(this.contributionsByEditor, instantiation.editorTypeId, []).push(contribution);
+                }
             }
-            contributions.push(contribution);
         }
     }
+    registerWorkbenchContribution(ctor, phase) {
+        this.registerWorkbenchContribution2(undefined, ctor, toWorkbenchPhase(phase));
+    }
+    getWorkbenchContribution(id) {
+        if (( this.instancesById.has(id))) {
+            return this.instancesById.get(id);
+        }
+        const instantiationService = this.instantiationService;
+        const lifecycleService = this.lifecycleService;
+        const logService = this.logService;
+        const environmentService = this.environmentService;
+        if (!instantiationService || !lifecycleService || !logService || !environmentService) {
+            throw new Error(`IWorkbenchContributionsRegistry#getContribution('${id}'): cannot be called before registry started`);
+        }
+        const contribution = this.contributionsById.get(id);
+        if (!contribution) {
+            throw new Error(`IWorkbenchContributionsRegistry#getContribution('${id}'): contribution with that identifier is unknown.`);
+        }
+        if (lifecycleService.phase < 3 ) {
+            logService.warn(`IWorkbenchContributionsRegistry#getContribution('${id}'): contribution instantiated before LifecyclePhase.Restored!`);
+        }
+        this.safeCreateContribution(instantiationService, logService, environmentService, contribution, lifecycleService.phase);
+        const instance = this.instancesById.get(id);
+        if (!instance) {
+            throw new Error(`IWorkbenchContributionsRegistry#getContribution('${id}'): failed to create contribution.`);
+        }
+        return instance;
+    }
     start(accessor) {
         const instantiationService = this.instantiationService = accessor.get(IInstantiationService);
         const lifecycleService = this.lifecycleService = accessor.get(ILifecycleService);
         const logService = this.logService = accessor.get(ILogService);
         const environmentService = this.environmentService = accessor.get(IEnvironmentService);
+        const editorPaneService = this.editorPaneService = accessor.get(IEditorPaneService);
         for (const phase of [1 , 2 , 3 , 4 ]) {
             this.instantiateByPhase(instantiationService, lifecycleService, logService, environmentService, phase);
         }
+        for (const editorTypeId of ( this.contributionsByEditor.keys())) {
+            if (editorPaneService.didInstantiateEditorPane(editorTypeId)) {
+                this.onEditor(editorTypeId, instantiationService, lifecycleService, logService, environmentService);
+            }
+        }
+        this._register(editorPaneService.onWillInstantiateEditorPane(e => this.onEditor(e.typeId, instantiationService, lifecycleService, logService, environmentService)));
+    }
+    onEditor(editorTypeId, instantiationService, lifecycleService, logService, environmentService) {
+        const contributions = this.contributionsByEditor.get(editorTypeId);
+        if (contributions) {
+            this.contributionsByEditor.delete(editorTypeId);
+            for (const contribution of contributions) {
+                this.safeCreateContribution(instantiationService, logService, environmentService, contribution, lifecycleService.phase);
+            }
+        }
     }
     instantiateByPhase(instantiationService, lifecycleService, logService, environmentService, phase) {
         if (lifecycleService.phase >= phase) {
@@ -46,9 +144,9 @@ class WorkbenchContributionsRegistry {
         }
     }
     async doInstantiateByPhase(instantiationService, logService, environmentService, phase) {
-        const contributions = this.contributions.get(phase);
+        const contributions = this.contributionsByPhase.get(phase);
         if (contributions) {
-            this.contributions.delete(phase);
+            this.contributionsByPhase.delete(phase);
             switch (phase) {
                 case 1 :
                 case 2 : {
@@ -93,20 +191,45 @@ class WorkbenchContributionsRegistry {
         runWhenGlobalIdle(instantiateSome, forcedTimeout);
     }
     safeCreateContribution(instantiationService, logService, environmentService, contribution, phase) {
-        const now = phase < 3  ? Date.now() : undefined;
+        if (typeof contribution.id === 'string' && ( this.instancesById.has(contribution.id))) {
+            return;
+        }
+        const now = Date.now();
         try {
-            instantiationService.createInstance(contribution);
+            if (typeof contribution.id === 'string') {
+                mark(`code/willCreateWorkbenchContribution/${phase}/${contribution.id}`);
+            }
+            const instance = instantiationService.createInstance(contribution.ctor);
+            if (typeof contribution.id === 'string') {
+                this.instancesById.set(contribution.id, instance);
+                this.contributionsById.delete(contribution.id);
+            }
         }
         catch (error) {
-            logService.error(`Unable to create workbench contribution ${contribution.name}.`, error);
+            logService.error(`Unable to create workbench contribution '${contribution.id ?? contribution.ctor.name}'.`, error);
         }
-        if (typeof now === 'number' && !environmentService.isBuilt ) {
+        finally {
+            if (typeof contribution.id === 'string') {
+                mark(`code/didCreateWorkbenchContribution/${phase}/${contribution.id}`);
+            }
+        }
+        if (typeof contribution.id === 'string' || !environmentService.isBuilt ) {
             const time = Date.now() - now;
-            if (time > 20) {
-                logService.warn(`Workbench contribution ${contribution.name} blocked restore phase by ${time}ms.`);
+            if (time > (phase < 3  ? WorkbenchContributionsRegistry.BLOCK_BEFORE_RESTORE_WARN_THRESHOLD : WorkbenchContributionsRegistry.BLOCK_AFTER_RESTORE_WARN_THRESHOLD)) {
+                logService.warn(`Creation of workbench contribution '${contribution.id ?? contribution.ctor.name}' took ${time}ms.`);
+            }
+            if (typeof contribution.id === 'string') {
+                let timingsForPhase = this.timingsByPhase.get(phase);
+                if (!timingsForPhase) {
+                    timingsForPhase = [];
+                    this.timingsByPhase.set(phase, timingsForPhase);
+                }
+                timingsForPhase.push([contribution.id, time]);
             }
         }
     }
 }
-Registry.add(Extensions.Workbench, ( new WorkbenchContributionsRegistry()));
-export { Extensions };
+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, WorkbenchPhase, getWorkbenchContribution, registerWorkbenchContribution2 };