@codingame/monaco-vscode-configuration-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/api/common/configurationExtensionPoint.js

@@ -1,10 +1,11 @@
+
 import { localize } from 'vscode/vscode/vs/nls';
 import { deepClone } from 'vscode/vscode/vs/base/common/objects';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-import { Extensions as Extensions$1, configurationDefaultsSchemaId, OVERRIDE_PROPERTY_REGEX, validateProperty, parseScope, getAllConfigurationProperties, getDefaultValue } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Extensions as Extensions$1, configurationDefaultsSchemaId, ConfigurationScope, OVERRIDE_PROPERTY_REGEX, validateProperty, parseScope, getAllConfigurationProperties, getDefaultValue } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { Extensions } from 'vscode/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
-import { workspaceSettingsSchemaId, launchSchemaId, tasksSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { workspaceSettingsSchemaId, launchSchemaId, tasksSchemaId } from '@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration';
 import { isObject, isUndefined } from 'vscode/vscode/vs/base/common/types';
 import { ExtensionIdentifierMap } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { Extensions as Extensions$2 } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
@@ -12,37 +13,37 @@ import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 
-const jsonRegistry = ( (Registry.as(Extensions.JSONContribution)));
-const configurationRegistry = ( (Registry.as(Extensions$1.Configuration)));
+const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
 const configurationEntrySchema = {
     type: 'object',
     defaultSnippets: [{ body: { title: '', properties: {} } }],
     properties: {
         title: {
             description: ( localize(
-                3627,
+                2370,
                 'A title for the current category of settings. This label will be rendered in the Settings editor as a subheading. If the title is the same as the extension display name, then the category will be grouped under the main extension heading.'
             )),
             type: 'string'
         },
         order: {
             description: ( localize(
-                3628,
+                2371,
                 'When specified, gives the order of this category of settings relative to other categories.'
             )),
             type: 'integer'
         },
         properties: {
-            description: ( localize(3629, 'Description of the configuration properties.')),
+            description: ( localize(2372, 'Description of the configuration properties.')),
             type: 'object',
             propertyNames: {
                 pattern: '\\S+',
-                patternErrorMessage: ( localize(3630, 'Property should not be empty.')),
+                patternErrorMessage: ( localize(2373, 'Property should not be empty.')),
             },
             additionalProperties: {
                 anyOf: [
                     {
-                        title: ( localize(3631, 'Schema of the configuration property.')),
+                        title: ( localize(2374, 'Schema of the configuration property.')),
                         $ref: 'http://json-schema.org/draft-07/schema#'
                     },
                     {
@@ -53,30 +54,30 @@ const configurationEntrySchema = {
                                 enum: ['application', 'machine', 'window', 'resource', 'language-overridable', 'machine-overridable'],
                                 default: 'window',
                                 enumDescriptions: [
-                                    ( localize(3632, "Configuration that can be configured only in the user settings.")),
+                                    ( localize(2375, "Configuration that can be configured only in the user settings.")),
                                     ( localize(
-                                        3633,
-                                        "Configuration that can be configured only in the user settings or only in the remote settings."
-                                    )),
+                                    2376,
+                                    "Configuration that can be configured only in the user settings or only in the remote settings."
+                                )),
                                     ( localize(
-                                        3634,
-                                        "Configuration that can be configured in the user, remote or workspace settings."
-                                    )),
+                                    2377,
+                                    "Configuration that can be configured in the user, remote or workspace settings."
+                                )),
                                     ( localize(
-                                        3635,
-                                        "Configuration that can be configured in the user, remote, workspace or folder settings."
-                                    )),
+                                    2378,
+                                    "Configuration that can be configured in the user, remote, workspace or folder settings."
+                                )),
                                     ( localize(
-                                        3636,
-                                        "Resource configuration that can be configured in language specific settings."
-                                    )),
+                                    2379,
+                                    "Resource configuration that can be configured in language specific settings."
+                                )),
                                     ( localize(
-                                        3637,
-                                        "Machine configuration that can be configured also in workspace or folder settings."
-                                    ))
+                                    2380,
+                                    "Machine configuration that can be configured also in workspace or folder settings."
+                                ))
                                 ],
                                 markdownDescription: ( localize(
-                                    3638,
+                                    2381,
                                     "Scope in which the configuration is applicable. Available scopes are `application`, `machine`, `window`, `resource`, and `machine-overridable`."
                                 ))
                             },
@@ -85,14 +86,14 @@ const configurationEntrySchema = {
                                 items: {
                                     type: 'string',
                                 },
-                                description: ( localize(3639, 'Descriptions for enum values'))
+                                description: ( localize(2382, 'Descriptions for enum values'))
                             },
                             markdownEnumDescriptions: {
                                 type: 'array',
                                 items: {
                                     type: 'string',
                                 },
-                                description: ( localize(3640, 'Descriptions for enum values in the markdown format.'))
+                                description: ( localize(2383, 'Descriptions for enum values in the markdown format.'))
                             },
                             enumItemLabels: {
                                 type: 'array',
@@ -100,26 +101,26 @@ const configurationEntrySchema = {
                                     type: 'string'
                                 },
                                 markdownDescription: ( localize(
-                                    3641,
+                                    2384,
                                     'Labels for enum values to be displayed in the Settings editor. When specified, the {0} values still show after the labels, but less prominently.',
                                     '`enum`'
                                 ))
                             },
                             markdownDescription: {
                                 type: 'string',
-                                description: ( localize(3642, 'The description in the markdown format.'))
+                                description: ( localize(2385, 'The description in the markdown format.'))
                             },
                             deprecationMessage: {
                                 type: 'string',
                                 description: ( localize(
-                                    3643,
+                                    2386,
                                     'If set, the property is marked as deprecated and the given message is shown as an explanation.'
                                 ))
                             },
                             markdownDeprecationMessage: {
                                 type: 'string',
                                 description: ( localize(
-                                    3644,
+                                    2387,
                                     'If set, the property is marked as deprecated and the given message is shown as an explanation in the markdown format.'
                                 ))
                             },
@@ -127,26 +128,26 @@ const configurationEntrySchema = {
                                 type: 'string',
                                 enum: ['singlelineText', 'multilineText'],
                                 enumDescriptions: [
-                                    ( localize(3645, 'The value will be shown in an inputbox.')),
-                                    ( localize(3646, 'The value will be shown in a textarea.'))
+                                    ( localize(2388, 'The value will be shown in an inputbox.')),
+                                    ( localize(2389, 'The value will be shown in a textarea.'))
                                 ],
                                 default: 'singlelineText',
                                 description: ( localize(
-                                    3647,
+                                    2390,
                                     'When specified, controls the presentation format of the string setting.'
                                 ))
                             },
                             order: {
                                 type: 'integer',
                                 description: ( localize(
-                                    3648,
+                                    2391,
                                     'When specified, gives the order of this setting relative to other settings within the same category. Settings with an order property will be placed before settings without this property set.'
                                 ))
                             },
                             ignoreSync: {
                                 type: 'boolean',
                                 description: ( localize(
-                                    3649,
+                                    2392,
                                     'When enabled, Settings Sync will not sync the user value of this configuration by default.'
                                 ))
                             },
@@ -162,7 +163,8 @@ const defaultConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'configurationDefaults',
     jsonSchema: {
         $ref: configurationDefaultsSchemaId,
-    }
+    },
+    canHandleResolver: true
 });
 defaultConfigurationExtPoint.setHandler((extensions, { added, removed }) => {
     if (_configDelta) {
@@ -176,21 +178,21 @@ defaultConfigurationExtPoint.setHandler((extensions, { added, removed }) => {
         }
     });
     if (removed.length) {
-        const removedDefaultConfigurations = ( (removed.map(
+        const removedDefaultConfigurations = ( removed.map(
             extension => ({ overrides: deepClone(extension.value), source: { id: extension.description.identifier.value, displayName: extension.description.displayName } })
-        )));
+        ));
         _configDelta.removedDefaults = removedDefaultConfigurations;
     }
     if (added.length) {
         const registeredProperties = configurationRegistry.getConfigurationProperties();
-        const allowedScopes = [6 , 3 , 4 , 5 ];
-        const addedDefaultConfigurations = ( (added.map(extension => {
+        const allowedScopes = [ConfigurationScope.MACHINE_OVERRIDABLE, ConfigurationScope.WINDOW, ConfigurationScope.RESOURCE, ConfigurationScope.LANGUAGE_OVERRIDABLE];
+        const addedDefaultConfigurations = ( added.map(extension => {
             const overrides = deepClone(extension.value);
-            for (const key of ( (Object.keys(overrides)))) {
+            for (const key of ( Object.keys(overrides))) {
                 const registeredPropertyScheme = registeredProperties[key];
                 if (registeredPropertyScheme?.disallowConfigurationDefault) {
                     extension.collector.warn(( localize(
-                        3650,
+                        2393,
                         "Cannot register configuration defaults for '{0}'. This setting does not allow contributing configuration defaults.",
                         key
                     )));
@@ -200,7 +202,7 @@ defaultConfigurationExtPoint.setHandler((extensions, { added, removed }) => {
                 if (!OVERRIDE_PROPERTY_REGEX.test(key)) {
                     if (registeredPropertyScheme?.scope && !allowedScopes.includes(registeredPropertyScheme.scope)) {
                         extension.collector.warn(( localize(
-                            3651,
+                            2394,
                             "Cannot register configuration defaults for '{0}'. Only defaults for machine-overridable, window, resource and language overridable scoped settings are supported.",
                             key
                         )));
@@ -210,7 +212,7 @@ defaultConfigurationExtPoint.setHandler((extensions, { added, removed }) => {
                 }
             }
             return { overrides, source: { id: extension.description.identifier.value, displayName: extension.description.displayName } };
-        })));
+        }));
         _configDelta.addedDefaults = addedDefaultConfigurations;
     }
 });
@@ -218,7 +220,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'configuration',
     deps: [defaultConfigurationExtPoint],
     jsonSchema: {
-        description: ( localize(3652, 'Contributes configuration settings.')),
+        description: ( localize(2395, 'Contributes configuration settings.')),
         oneOf: [
             configurationEntrySchema,
             {
@@ -226,9 +228,10 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 items: configurationEntrySchema
             }
         ]
-    }
+    },
+    canHandleResolver: true
 });
-const extensionConfigurations = ( (new ExtensionIdentifierMap()));
+const extensionConfigurations = ( new ExtensionIdentifierMap());
 configurationExtPoint.setHandler((extensions, { added, removed }) => {
     _configDelta ??= {};
     if (removed.length) {
@@ -239,11 +242,11 @@ configurationExtPoint.setHandler((extensions, { added, removed }) => {
         }
         _configDelta.removedConfigurations = removedConfigurations;
     }
-    const seenProperties = ( (new Set()));
+    const seenProperties = ( new Set());
     function handleConfiguration(node, extension) {
         const configuration = deepClone(node);
         if (configuration.title && (typeof configuration.title !== 'string')) {
-            extension.collector.error(( localize(3653, "'configuration.title' must be a string")));
+            extension.collector.error(( localize(2396, "'configuration.title' must be a string")));
         }
         validateProperties(configuration, extension);
         configuration.id = node.id || extension.description.identifier.value;
@@ -256,7 +259,7 @@ configurationExtPoint.setHandler((extensions, { added, removed }) => {
         const properties = configuration.properties;
         if (properties) {
             if (typeof properties !== 'object') {
-                extension.collector.error(( localize(3654, "'configuration.properties' must be an object")));
+                extension.collector.error(( localize(2397, "'configuration.properties' must be an object")));
                 configuration.properties = {};
             }
             for (const key in properties) {
@@ -267,24 +270,24 @@ configurationExtPoint.setHandler((extensions, { added, removed }) => {
                     extension.collector.warn(message);
                     continue;
                 }
-                if (( (seenProperties.has(key)))) {
+                if (( seenProperties.has(key))) {
                     delete properties[key];
-                    extension.collector.warn(( localize(3655, "Cannot register '{0}'. This property is already registered.", key)));
+                    extension.collector.warn(( localize(2398, "Cannot register '{0}'. This property is already registered.", key)));
                     continue;
                 }
                 if (!isObject(propertyConfiguration)) {
                     delete properties[key];
-                    extension.collector.error(( localize(3656, "configuration.properties property '{0}' must be an object", key)));
+                    extension.collector.error(( localize(2399, "configuration.properties property '{0}' must be an object", key)));
                     continue;
                 }
                 seenProperties.add(key);
-                propertyConfiguration.scope = propertyConfiguration.scope ? parseScope(( (propertyConfiguration.scope.toString()))) : 3 ;
+                propertyConfiguration.scope = propertyConfiguration.scope ? parseScope(( propertyConfiguration.scope.toString())) : ConfigurationScope.WINDOW;
             }
         }
         const subNodes = configuration.allOf;
         if (subNodes) {
             extension.collector.error(( localize(
-                3657,
+                2400,
                 "'configuration.allOf' is deprecated and should no longer be used. Instead, pass multiple configuration sections as an array to the 'configuration' contribution point."
             )));
             for (const node of subNodes) {
@@ -327,7 +330,7 @@ jsonRegistry.registerSchema('vscode://schemas/workspaceConfig', {
         'folders': {
             minItems: 0,
             uniqueItems: true,
-            description: ( localize(3658, "List of folders to be loaded in the workspace.")),
+            description: ( localize(2401, "List of folders to be loaded in the workspace.")),
             items: {
                 type: 'object',
                 defaultSnippets: [{ body: { path: '$1' } }],
@@ -336,13 +339,13 @@ jsonRegistry.registerSchema('vscode://schemas/workspaceConfig', {
                             path: {
                                 type: 'string',
                                 description: ( localize(
-                                    3659,
+                                    2402,
                                     "A file path. e.g. `/root/folderA` or `./folderA` for a relative path that will be resolved against the location of the workspace file."
                                 ))
                             },
                             name: {
                                 type: 'string',
-                                description: ( localize(3660, "An optional name for the folder. "))
+                                description: ( localize(2403, "An optional name for the folder. "))
                             }
                         },
                         required: ['path']
@@ -350,11 +353,11 @@ jsonRegistry.registerSchema('vscode://schemas/workspaceConfig', {
                         properties: {
                             uri: {
                                 type: 'string',
-                                description: ( localize(3661, "URI of the folder"))
+                                description: ( localize(2404, "URI of the folder"))
                             },
                             name: {
                                 type: 'string',
-                                description: ( localize(3660, "An optional name for the folder. "))
+                                description: ( localize(2403, "An optional name for the folder. "))
                             }
                         },
                         required: ['uri']
@@ -364,39 +367,39 @@ jsonRegistry.registerSchema('vscode://schemas/workspaceConfig', {
         'settings': {
             type: 'object',
             default: {},
-            description: ( localize(3662, "Workspace settings")),
+            description: ( localize(2405, "Workspace settings")),
             $ref: workspaceSettingsSchemaId
         },
         'launch': {
             type: 'object',
             default: { configurations: [], compounds: [] },
-            description: ( localize(3663, "Workspace launch configurations")),
+            description: ( localize(2406, "Workspace launch configurations")),
             $ref: launchSchemaId
         },
         'tasks': {
             type: 'object',
             default: { version: '2.0.0', tasks: [] },
-            description: ( localize(3664, "Workspace task configurations")),
+            description: ( localize(2407, "Workspace task configurations")),
             $ref: tasksSchemaId
         },
         'extensions': {
             type: 'object',
             default: {},
-            description: ( localize(3665, "Workspace extensions")),
+            description: ( localize(2408, "Workspace extensions")),
             $ref: 'vscode://schemas/extensions'
         },
         'remoteAuthority': {
             type: 'string',
             doNotSuggest: true,
-            description: ( localize(3666, "The remote server where the workspace is located.")),
+            description: ( localize(2409, "The remote server where the workspace is located.")),
         },
         'transient': {
             type: 'boolean',
             doNotSuggest: true,
-            description: ( localize(3667, "A transient workspace will disappear when restarting or reloading.")),
+            description: ( localize(2410, "A transient workspace will disappear when restarting or reloading.")),
         }
     },
-    errorMessage: ( localize(3668, "Unknown workspace configuration property"))
+    errorMessage: ( localize(2411, "Unknown workspace configuration property"))
 });
 class SettingsTableRenderer extends Disposable {
     constructor() {
@@ -411,16 +414,16 @@ class SettingsTableRenderer extends Disposable {
             ? Array.isArray(manifest.contributes.configuration) ? manifest.contributes.configuration : [manifest.contributes.configuration]
             : [];
         const properties = getAllConfigurationProperties(configuration);
-        const contrib = properties ? ( (Object.keys(properties))) : [];
-        const headers = [( localize(3669, "ID")), ( localize(3670, "Description")), ( localize(3671, "Default"))];
-        const rows = ( (contrib.sort((a, b) => a.localeCompare(b))
+        const contrib = ( Object.keys(properties)) ;
+        const headers = [( localize(2412, "ID")), ( localize(2413, "Description")), ( localize(2414, "Default"))];
+        const rows = ( contrib.sort((a, b) => a.localeCompare(b))
             .map(key => {
             return [
-                ( (new MarkdownString())).appendMarkdown(`\`${key}\``),
-                properties[key].markdownDescription ? ( (new MarkdownString(properties[key].markdownDescription, false))) : properties[key].description ?? '',
-                ( (new MarkdownString())).appendCodeblock('json', JSON.stringify(isUndefined(properties[key].default) ? getDefaultValue(properties[key].type) : properties[key].default, null, 2)),
+                ( new MarkdownString()).appendMarkdown(`\`${key}\``),
+                properties[key].markdownDescription ? ( new MarkdownString(properties[key].markdownDescription, false)) : properties[key].description ?? '',
+                ( new MarkdownString()).appendCodeblock('json', JSON.stringify(isUndefined(properties[key].default) ? getDefaultValue(properties[key].type) : properties[key].default, null, 2)),
             ];
-        })));
+        }));
         return {
             data: {
                 headers,
@@ -430,11 +433,11 @@ class SettingsTableRenderer extends Disposable {
         };
     }
 }
-( (Registry.as(Extensions$2.ExtensionFeaturesRegistry))).registerExtensionFeature({
+( Registry.as(Extensions$2.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: 'configuration',
-    label: ( localize(3672, "Settings")),
+    label: ( localize(2415, "Settings")),
     access: {
         canToggle: false
     },
-    renderer: ( (new SyncDescriptor(SettingsTableRenderer))),
+    renderer: ( new SyncDescriptor(SettingsTableRenderer)),
 });

package/vscode/src/vs/workbench/contrib/workspaces/browser/workspaces.contribution.d.ts

@@ -0,0 +1,19 @@
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IHostService } from "vscode/vscode/vs/workbench/services/host/browser/host.service";
+import { IQuickInputService } from "vscode/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+export declare class WorkspacesFinderContribution extends Disposable implements IWorkbenchContribution {
+    private readonly contextService;
+    private readonly notificationService;
+    private readonly fileService;
+    private readonly quickInputService;
+    private readonly hostService;
+    private readonly storageService;
+    constructor(contextService: IWorkspaceContextService, notificationService: INotificationService, fileService: IFileService, quickInputService: IQuickInputService, hostService: IHostService, storageService: IStorageService);
+    private findWorkspaces;
+    private doHandleWorkspaceFiles;
+}

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

@@ -1,8 +1,10 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { hasWorkspaceFileExtension, WORKSPACE_SUFFIX } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { WorkbenchState, hasWorkspaceFileExtension, WORKSPACE_SUFFIX } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
@@ -11,13 +13,14 @@ import { INotificationService } from 'vscode/vscode/vs/platform/notification/com
 import { joinPath, isEqual } from 'vscode/vscode/vs/base/common/resources';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { StorageScope } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { isVirtualWorkspace } from 'vscode/vscode/vs/platform/workspace/common/virtualWorkspace';
+import { isVirtualWorkspace } from '@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common/vscode/vs/platform/workspace/common/virtualWorkspace';
 import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { ResourceContextKey, ActiveEditorContext, TemporaryWorkspaceContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { TEXT_FILE_EDITOR_ID } from 'vscode/vscode/vs/workbench/contrib/files/common/files';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { TEXT_FILE_EDITOR_ID } from '@codingame/monaco-vscode-cc9ccbec-e2a1-599d-84ae-46f5efc666e3-common/vscode/vs/workbench/contrib/files/common/files';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 let WorkspacesFinderContribution = class WorkspacesFinderContribution extends Disposable {
     constructor(contextService, notificationService, fileService, quickInputService, hostService, storageService) {
@@ -32,7 +35,7 @@ let WorkspacesFinderContribution = class WorkspacesFinderContribution extends Di
     }
     async findWorkspaces() {
         const folder = this.contextService.getWorkspace().folders[0];
-        if (!folder || this.contextService.getWorkbenchState() !== 2  || isVirtualWorkspace(this.contextService.getWorkspace())) {
+        if (!folder || this.contextService.getWorkbenchState() !== WorkbenchState.FOLDER || isVirtualWorkspace(this.contextService.getWorkspace())) {
             return;
         }
         const rootFileNames = (await this.fileService.resolve(folder.uri)).children?.map(child => child.name);
@@ -47,28 +50,28 @@ let WorkspacesFinderContribution = class WorkspacesFinderContribution extends Di
         const neverShowAgain = { id: 'workspaces.dontPromptToOpen', scope: NeverShowAgainScope.WORKSPACE, isSecondary: true };
         if (workspaces.length === 1) {
             const workspaceFile = workspaces[0];
-            this.notificationService.prompt(Severity$1.Info, ( localize(
-                3673,
+            this.notificationService.prompt(Severity.Info, ( localize(
+                11119,
                 "This folder contains a workspace file '{0}'. Do you want to open it? [Learn more]({1}) about workspace files.",
                 workspaceFile,
                 'https://go.microsoft.com/fwlink/?linkid=2025315'
             )), [{
-                    label: ( localize(3674, "Open Workspace")),
+                    label: ( localize(11120, "Open Workspace")),
                     run: () => this.hostService.openWindow([{ workspaceUri: joinPath(folder, workspaceFile) }])
                 }], {
                 neverShowAgain,
-                priority: !this.storageService.isNew(1 ) ? NotificationPriority.SILENT : undefined
+                priority: !this.storageService.isNew(StorageScope.WORKSPACE) ? NotificationPriority.SILENT : undefined
             });
         }
         else if (workspaces.length > 1) {
-            this.notificationService.prompt(Severity$1.Info, ( localize(
-                3675,
+            this.notificationService.prompt(Severity.Info, ( localize(
+                11121,
                 "This folder contains multiple workspace files. Do you want to open one? [Learn more]({0}) about workspace files.",
                 'https://go.microsoft.com/fwlink/?linkid=2025315'
             )), [{
-                    label: ( localize(3676, "Select Workspace")),
+                    label: ( localize(11122, "Select Workspace")),
                     run: () => {
-                        this.quickInputService.pick(( (workspaces.map(workspace => ({ label: workspace })))), { placeHolder: ( localize(3677, "Select a workspace to open")) }).then(pick => {
+                        this.quickInputService.pick(( workspaces.map(workspace => ({ label: workspace }))), { placeHolder: ( localize(11123, "Select a workspace to open")) }).then(pick => {
                             if (pick) {
                                 this.hostService.openWindow([{ workspaceUri: joinPath(folder, pick.label) }]);
                             }
@@ -76,33 +79,29 @@ let WorkspacesFinderContribution = class WorkspacesFinderContribution extends Di
                     }
                 }], {
                 neverShowAgain,
-                priority: !this.storageService.isNew(1 ) ? NotificationPriority.SILENT : undefined
+                priority: !this.storageService.isNew(StorageScope.WORKSPACE) ? NotificationPriority.SILENT : undefined
             });
         }
     }
 };
-WorkspacesFinderContribution = ( (__decorate([
-    ( (__param(0, IWorkspaceContextService))),
-    ( (__param(1, INotificationService))),
-    ( (__param(2, IFileService))),
-    ( (__param(3, IQuickInputService))),
-    ( (__param(4, IHostService))),
-    ( (__param(5, IStorageService)))
-], WorkspacesFinderContribution)));
-( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(WorkspacesFinderContribution, 4 );
+WorkspacesFinderContribution = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, INotificationService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IHostService)),
+    ( __param(5, IStorageService))
+], WorkspacesFinderContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkspacesFinderContribution, LifecyclePhase.Eventually);
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.openWorkspaceFromEditor',
-            title: ( localize2(3674, "Open Workspace")),
+            title: ( localize2(11120, "Open Workspace")),
             f1: false,
             menu: {
                 id: MenuId.EditorContent,
-                when: ( (ContextKeyExpr.and(
-                     (ResourceContextKey.Extension.isEqualTo(WORKSPACE_SUFFIX)),
-                     (ActiveEditorContext.isEqualTo(TEXT_FILE_EDITOR_ID)),
-                     (TemporaryWorkspaceContext.toNegated())
-                )))
+                when: ( ContextKeyExpr.and(( ResourceContextKey.Extension.isEqualTo(WORKSPACE_SUFFIX)), ( ActiveEditorContext.isEqualTo(TEXT_FILE_EDITOR_ID)), ( TemporaryWorkspaceContext.toNegated())))
             }
         });
     }
@@ -110,10 +109,10 @@ registerAction2(class extends Action2 {
         const hostService = accessor.get(IHostService);
         const contextService = accessor.get(IWorkspaceContextService);
         const notificationService = accessor.get(INotificationService);
-        if (contextService.getWorkbenchState() === 3 ) {
+        if (contextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
             const workspaceConfiguration = contextService.getWorkspace().configuration;
             if (workspaceConfiguration && isEqual(workspaceConfiguration, uri)) {
-                notificationService.info(( localize(3678, "This workspace is already open.")));
+                notificationService.info(( localize(11124, "This workspace is already open.")));
                 return;
             }
         }